<!DOCTYPE html>
<html>

<head>
	<meta charset="utf-8">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<title>new_file</title>
	<link rel="stylesheet" href="../css/marked_css.css" />
	<link rel="stylesheet" href="../css/obsidian-theme.css">
	<script src="../javaScript/prettify.js"></script>
	<script src="../javaScript/jquery-3.4.1.js"></script>
	<script>$(function(){prettyPrint();})</script>
</head>

<body class="stackedit" id="stackedit">
    <div class="stackedit__html">
<h1><a id="_1"></a>基础使用说明</h1>
<p>本小节主要针对框架中一些相对细小和基础的知识点进行说明，阅读完本小节之后能够帮助你更好的理解之后的章节内容。</p>
<h2><a id="_3"></a>一、安装</h2>
<p>你可以通过pip包管理工具键入“框架名称” 或者 “框架.whl文件的绝对路径(存放在仓库的dist文件夹下)”完成框架的安装，详情如下:</p>
<ul>
<li><code>pip install -i https://test.pypi.org/simple/ kdtest==1.1.4</code></li>
<li><code>pip install  C:/xxxxxx/kdtest-1.1.4-py3-none-any.whl</code></li>
</ul>
<p>你可以在控制台中键入 <code>kdtest -v</code> 来验证是否安装成功。</p>
<blockquote>
<p>1.1.4为当前框架最新版本</p>
</blockquote>
<h2><a id="_11"></a>二、运行</h2>
<p>你可以在系统自带的“cmd命令提示符”或者各编译器“PyCharm、Visual Studio Code”中的控制台键入 命令(框架命令)来运行框架，详情如下：</p>
<ul>
<li><code>kdtest</code></li>
<li><code>kdtest --startup</code></li>
<li><code>kdtest --startup startup</code></li>
</ul>
<blockquote>
<p>三条命令功能和处理逻辑均一致，<code>kdtest</code> 和 <code>kdtest --startup</code> 为“命令参数缺省”状态</p>
</blockquote>
<h2><a id="_18"></a>三、框架命令可选参数</h2>

<table>
<thead>
<tr>
<th align="center">命令字句</th>
<th align="center">解释说明</th>
<th align="center">参数</th>
<th align="left">示例语句</th>
</tr>
</thead>
<tbody>
<tr>
<td align="center"><font size="2">- -version [-v]</font></td>
<td align="center"><font size="2">当前安装的框架版本号</font></td>
<td align="center"><font size="2">None</font></td>
<td align="left"><font size="2">kdtest --version</font></td>
</tr>
<tr>
<td align="center"><font size="2">- -help [-h]</font></td>
<td align="center"><font size="2">框架命令字句提示帮助</font></td>
<td align="center"><font size="2">None</font></td>
<td align="left"><font size="2">kdtest --help</font></td>
</tr>
<tr>
<td align="center"><font size="2">- -new [-n]</font></td>
<td align="center"><font size="2">框架用例数据包生成</font></td>
<td align="center"><font size="2">None</font></td>
<td align="left"><font size="2">kdtest --new</font></td>
</tr>
<tr>
<td align="center"><font size="2">- -change [-c]</font></td>
<td align="center"><font size="2">框架自定义配置文件生成</font></td>
<td align="center"><font size="2">None</font></td>
<td align="left"><font size="2">kdtest --change</font></td>
</tr>
<tr>
<td align="center"><font size="2">- -parameter [-p]</font></td>
<td align="center"><font size="2">框架静态参数配置文件生成</font></td>
<td align="center"><font size="2">None</font></td>
<td align="left"><font size="2">kdtest --parameter</font></td>
</tr>
<tr>
<td align="center"><font size="2">- -st</font></td>
<td align="center"><font size="2">框架初始化清除脚本生成</font></td>
<td align="center"><font size="2">None</font></td>
<td align="left"><font size="2">kdtest --st</font></td>
</tr>
<tr>
<td align="center"><font size="2">- -unit_new</font></td>
<td align="center"><font size="2">框架自定义插件包模板生成</font></td>
<td align="center"><font size="2">None</font></td>
<td align="left"><font size="2">kdtest --unit_new</font></td>
</tr>
<tr>
<td align="center"><font size="2">- -unit_show</font></td>
<td align="center"><font size="2">显示框架中目前安装的插件</font></td>
<td align="center"><font size="2">None</font></td>
<td align="left"><font size="2">kdtest --unit_show</font></td>
</tr>
<tr>
<td align="center"><font size="2">- -unit_install</font></td>
<td align="center"><font size="2"> 框架自定义插件包安装</font></td>
<td align="center"><font size="2">插件包绝对路径</font></td>
<td align="left"><font size="2">kdtest --unit_install C:\xx --unit_install C:\xx</font></td>
</tr>
<tr>
<td align="center"><font size="2">- -unit_uninstall</font></td>
<td align="center"><font size="2">框架自定义插件包卸载</font></td>
<td align="center"><font size="2">插件包名称</font></td>
<td align="left"><font size="2">kdtest --unit_uninstall xxx --unit_uninstall xxx</font></td>
</tr>
<tr>
<td align="center"><font size="2">- -log</font></td>
<td align="center"><font size="2">测试报告名称指定</font></td>
<td align="center"><font size="2">测试报告名称</font></td>
<td align="left"><font size="2">kdtest --log  xxxx</font></td>
</tr>
<tr>
<td align="center"><font size="2">- -startup</font></td>
<td align="center"><font size="2">框架启动</font></td>
<td align="center"><font size="2">startup</font></td>
<td align="left"><font size="2">kdtest --startup  //  kdtest --startup startup</font></td>
</tr>
</tbody>
</table><blockquote>
<p>注：[-x]代表该命令字句可支持简写</p>
</blockquote>
<blockquote>
<p>注意：<code>--log  [名称]</code> 命令仅支持在 <code>1.1.3</code> 及以上版本的框架中使用；键入<code>kdtest --log 第一轮集成测试</code>命令，在用例执行结束后会将生成的测试报告名称更改为 “第一轮集成测试”。</p>
</blockquote>
<h1><a id="_38"></a>框架使用前须知</h1>
<h2><a id="_39"></a>一、必要准备</h2>
<ul>
<li><p>1、在使用框架前你需要找到一个无权限限制的系统目录来作为你的工作目录(是否为空均可)，原因则是框架在执行过程中需要进行大量的文件夹和文件操作，所以需要你尽可能避免使用一些敏感目录来作为工作目录。</p></li>
<li><p>2、在你的工作目录中应该存在一个名为 <code>casesAggregate</code> 的文件夹(称为“用例数据包”，该文件夹名称可按照个人喜好自定义)，用来存放你的用例文件以及一些和用例相关的数据文件。你可以通过框架命令<code>kdtest -n</code> 或者 <code>kdtest --new</code> 让框架在你的工作目录中自动创建。</p></li>
<li><p>3、保证你的工作目录中存在框架的“参数配置文件”<code>parameters.json</code>(该文件名称可按照个人喜好自定义)，你可以通过框架命令<code>kdtest -p</code> 或者 <code>kdtest --parameter</code> 让框架在你的工作目录中自动创建。另外你需要文件中的提示完成参数配置。</p></li>
</ul>
<h2><a id="_43"></a>二、注意事项</h2>
<ul>
<li>
<p>你的工作目录并不需要唯一；你在何处运行框架框架就会视此处为你的工作目录，当然你甚至可以在一个工作目录中嵌套创建一个工作目录，这并不会影响框架。</p>
</li>
<li>
<p>在“用例数据包”中，框架认定以 <code>interface_</code> 开头的文件夹为“接口数据文件夹”(该文件夹名称可按照个人喜好自定义)，以 <code>element_</code> 开头的文件夹为“元素节点数据文件夹”(该文件夹名称可按照个人喜好自定义)，分别用来存放你的需要配合用例一起执行的“接口数据”和“元素节点数据”。需要注意的是这两个文件夹并不是必须存在的你需要哪一项就创建那一项，如果都不需要则可以都不创建。框架之所以规定它们是为了能够更好的找到与用例对应的数据文件，仅此而已。</p>
</li>
<li>
<p>框架在运行过程中会自动在你的工作目录中生成几个文件夹，分别为“ <code>download</code> (可按照个人喜好自定义)存放被测系统中下载或者导出的文件”、“ <code>result\report</code> (可按照个人喜好自定义)存放测试结果报告.html”、“ <code>result\log </code> (可按照个人喜好自定义)存放框架运行日志”。</p>
</li>
<li>
<p>如果你想要在你的测试用例开始执行前或者结束执行后做些事情，可以通过键入 <code>-&gt; kdtest --st</code> 命令来让框架为你创建一个“初始化清除脚本 <code>__st__.py</code> (名称可按照个人喜好自定义)”，你只需要按照文件中的提示和引导对其进行编写。</p>
<pre><code># __st__.py

# from kdtest import GSTORE, INFO

def suite_setup():
    # 初始化

def suite_teardown():
    # 清除
</code></pre>
</li>
</ul>
<blockquote>
<p>注意：download、result\report、result\log 这三个文件夹在你的工作目录中不是必须存在的，在不需要的时候你可以直接把它们删除，框架会在重新生成。</p>
</blockquote>
<blockquote>
<p>注意：<code>parameters.json</code> 和 <code>__st__.py</code> 两个文件中预先写好的“key键名” 和 “函数名”，不可随意更改。</p>
</blockquote>
<blockquote>
<p>可自定义的文件、文件夹名称修改方法：在框架的安装目录中(通常为pyton解释器安装目录中的 <code>\Lib\site-packages\kdtest</code> 文件夹)找到common.py文件，文件中带有 “通用名称”标注的变量值均可以修改，你只需要找到要修改的文件或文件夹名称对应的变量即可。</p>
</blockquote>
<p><em>可自定义的文件、文件夹名称修改方法代码展示</em></p>
<pre><code># common.py

# 通用名称
CASES = "casesAggregate"  # 用例数据包
INTER = "interface_"  # 接口数据文件夹名称格式限定
ELE = "element_"  # 元素节点数据文件夹名称格式限定
RE = "result\\report"  # excel测试结果目录结构
RL = "result\\log"  # 运行日志测试结果目录结构
DOWN = "download"  # 指定下载文件夹名称
PIUG = "plugins"  # 自定义插件默认包文件夹名称
P = "CJ_1"  # 自定义插件默认文件夹名称
P_E = "elementData"  # 自定义插件默认数据文件夹名称
P_U = "utils"  # 自定义插件默认工具文件夹名称
P_INI = "my"  # 自定义插件默认配置文件名称
P_M = "module"  # 自定义插件默认文件名称
P_EY = "elementData"  # 自定义插件默认数据文件名称
CHANGE = "change"  # 框架自定义配置文件名称
PARA = "parameters"  # 框架静态启动参数配置文件名称
ST = "__st__"  # 框架初始化清除脚本文件名称
</code></pre>
<h2><a id="_92"></a>三、用例数据包解释</h2>
<p>用例数据包的名称必须为固定，框架默认为 <code>casesAggregate</code>，该名称你可以根据个人喜好自定义；若实际的文件夹名称与指定的文件夹名称不一致，则框架视其为不存在。</p>
<h3><a id="1__94"></a>1. 子文件夹</h3>
<ul>
<li>在“用例数据包”中以 <code>element_</code>(可自定义) 开头的文件夹被框架视为“用例元素节点文件夹”，用于存放测试用例所依赖的元素节点数据。</li>
<li>在“用例数据包”中以 <code>interface_</code>(可自定义) 开头的文件夹被框架视为“用例接口数据文件夹”，用于存放测试用例所依赖的接口数据。</li>
</ul>
<blockquote>
<p>注：限定规则可根据个人喜好自行修改(修改方法，见“注意事项 - 可自定义的文件、文件夹名称修改方法代码展示”)，且以上两个文件夹均不是必须存在的。</p>
</blockquote>
<h3><a id="2__99"></a>2. 子文件</h3>
<ul>
<li>
<p>用例步骤文件： 框架将存放在 “用例数据包” 中的所有Excel工作簿视为合法有效的用例步骤文件(不包含存放在“用例元素节点文件夹”和“用例接口数据文件夹”中的文件)；主要用于书写框架可操作的“测试用例”，一个Excel工作簿文件代表一组测试用例，工作簿中的单个Sheet表代表一条测试用例，每个工作表中的一个单元行代表一个用例步骤。</p>
</li>
<li>
<p>接口数据文件：框架将存放在 “用例接口数据文件夹”中的以InterfaceData命名的.yaml文件视为合法有效的接口数据文件。</p>
</li>
<li>
<p>元素节点数据文件：框架将存放在 “用例元素节点文件夹”中的以elementData命名的.yaml文件视为合法有效的元素节点数据文件。</p>
</li>
</ul>
<blockquote>
<p>注意：<code>InterfaceData.yaml</code> 和 <code>elementData.yaml</code> 文件名不可随意修改，否则框架将视其为不存在。</p>
</blockquote>
<blockquote>
<p>注意：在存放指定用例所依赖的<code>InterfaceData.yaml</code> 和 <code>elementData.yaml</code> 文件时，需要原样复刻“用例步骤文件”的目录结构，原因则是框架会根据“用例步骤文件”的目录结构追踪与之匹配的<code>InterfaceData.yaml</code> 和 <code>elementData.yaml</code> 文件。</p>
</blockquote>
<blockquote>
<p>以上介绍的三种文件的详细书写规则请参考 “用例步骤文件书写声明”、“接口数据文件书写声明”、“元素节点文件书写声明”。</p>
</blockquote>
<ul>
<li>用例步骤文件存放目录为: casesAggregate\2022_v11THEME\personalAffairs\E_Mail</li>
<li>对应的<code>elementData.yaml</code>存放目录应为: casesAggregate\element_用例元素节点文件夹\2022_v11THEME\personalAffairs\E_Mail</li>
<li>对应的<code>InterfaceData.yaml</code>存放目录应为: casesAggregate\interface_用例接口数据文件夹\2022_v11THEME\personalAffairs\E_Mail</li>
</ul>
<h2><a id="_115"></a>四、框架中支持使用的元素定位方式和元素索引标识</h2>
<p>目前框架中支持使用7种定位方式，每种定位方式均支持“单元素定位”和“复数元素定位”两种形式。为了能够更好的与selenium框架中的定位方式进行区分，对几个比较敏感的定位方式名称做了修改，详细的内容如下表所示：</p>

<table>
<thead>
<tr>
<th>单元素定位形式</th>
<th>复数定位形式</th>
</tr>
</thead>
<tbody>
<tr>
<td>id</td>
<td>ids</td>
</tr>
<tr>
<td>name</td>
<td>names</td>
</tr>
<tr>
<td>class_name</td>
<td>class_names</td>
</tr>
<tr>
<td>css_selector</td>
<td>css_selectors</td>
</tr>
<tr>
<td>xpath</td>
<td>xpaths</td>
</tr>
<tr>
<td>link_text</td>
<td>link_texts</td>
</tr>
<tr>
<td>tag_name</td>
<td>tag_names</td>
</tr>
</tbody>
</table><blockquote>
<p>“复数定位”就是在单元素定位方式名称的后面加上’s’</p>
</blockquote>
<blockquote>
<p>“单元素定位”获取结果：elementObject；“复数元素定位”获取结果：[elementObject]</p>
</blockquote>
<p>在进行“复数元素定位”时，框架支持使用“位置索引”来对元素列表进行筛选，目前框架中可识别处理的索引标识有三种，其各自的书写形式和含义如下表所示：</p>

<table>
<thead>
<tr>
<th>索引标识</th>
<th>含义</th>
</tr>
</thead>
<tbody>
<tr>
<td>0</td>
<td>取定位元素列表第一项</td>
</tr>
<tr>
<td>last</td>
<td>取定位元素列表最后一项</td>
</tr>
<tr>
<td>center</td>
<td>取定位元素列表索引位置折中项</td>
</tr>
</tbody>
</table><p>使用示例：</p>
<pre><code class="prism language-yaml"><span class="token key atrule">key1</span><span class="token punctuation">:</span>
	<span class="token key atrule">key2</span><span class="token punctuation">:</span>
		<span class="token punctuation">-</span> ids  <span class="token comment"># 定位页面中所有id属性值为‘kw’的元素</span>
		<span class="token punctuation">-</span> kw

假设通过上面的元素定位信息，找出的元素结果为：<span class="token punctuation">[</span>elementObject1<span class="token punctuation">,</span> elementObject2<span class="token punctuation">,</span>elementObject3<span class="token punctuation">,</span>elementObject4<span class="token punctuation">,</span>elementObject5<span class="token punctuation">]</span>

例子1<span class="token punctuation">---</span><span class="token punctuation">-</span><span class="token punctuation">-</span> 此时我们给它加上索引筛选，取出结果列表中的第一个：
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
	<span class="token key atrule">key2</span><span class="token punctuation">:</span>
		<span class="token punctuation">-</span> ids  <span class="token comment"># 定位页面中所有id属性值为‘kw’的元素</span>
		<span class="token punctuation">-</span> kw
		<span class="token punctuation">-</span> <span class="token number">0</span>  <span class="token comment">#  取元素定位列表中的第一项</span>
最后的定位结果为：elementObject1，注意此时的定位结果就不再是一个<span class="token punctuation">[</span><span class="token punctuation">]</span>列表了


例子2<span class="token punctuation">---</span><span class="token punctuation">-</span><span class="token punctuation">-</span> 此时我们给它加上索引筛选，取出结果列表中索引位置折中的一个：
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
	<span class="token key atrule">key2</span><span class="token punctuation">:</span>
		<span class="token punctuation">-</span> ids  <span class="token comment"># 定位页面中所有id属性值为‘kw’的元素</span>
		<span class="token punctuation">-</span> kw
		<span class="token punctuation">-</span> center  <span class="token comment">#  取元素定位列表中的折中项</span>
最后的定位结果为：elementObject3，注意此时的定位结果就不再是一个<span class="token punctuation">[</span><span class="token punctuation">]</span>列表了

例子3<span class="token punctuation">---</span><span class="token punctuation">-</span><span class="token punctuation">-</span> 此时我们给它加上索引筛选，取出结果列表中的最后一项：
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
	<span class="token key atrule">key2</span><span class="token punctuation">:</span>
		<span class="token punctuation">-</span> ids  <span class="token comment"># 定位页面中所有id属性值为‘kw’的元素</span>
		<span class="token punctuation">-</span> kw
		<span class="token punctuation">-</span> last  <span class="token comment">#  取元素定位列表中的最后一项</span>
最后的定位结果为：elementObject5，注意此时的定位结果就不再是一个<span class="token punctuation">[</span><span class="token punctuation">]</span>列表了
</code></pre>
<blockquote>
<p>注意：若你在进行单元素定位时，你传入的索引标识将被框架视为无效；在一些必须明确指定操作元素的关键字中，若你传入的复数元素定位信息中不带有索引标识，则框架默认取定位列表中索引位置为0的元素。</p>
</blockquote>
<table>
<thead>
<tr>
<th>必须明确指定操作元素的关键字</th>
<th>功能说明概要</th>
</tr>
</thead>
<tbody>
<tr>
<td><a href="#input_text">input_text</a></td>
<td>指定元素内容输入</td>
</tr>
<tr>
<td><a href="#click_btn">click_btn</a></td>
<td>指定元素点击</td>
</tr>
<tr>
<td><a href="#selector_operation">selector_operation</a></td>
<td>指定<code>&lt;select&gt;</code>元素列表项选择</td>
</tr>
<tr>
<td><a href="#radioCheck_operation">radioCheck_operation</a></td>
<td>指定“单/复选按钮”选中</td>
</tr>
<tr>
<td><a href="#drag_scrollBar">drag_scrollBar</a></td>
<td>指定元素窗口滚动条拖动</td>
</tr>
<tr>
<td><a href="#ternary_Judgement">ternary_Judgement</a></td>
<td>三元判断控制</td>
</tr>
<tr>
<td><a href="#selector_assert">selector_assert</a></td>
<td>指定<code>&lt;select&gt;</code>元素列表项检查断言</td>
</tr>
<tr>
<td><a href="#elementExistence_assert">elementExistence_assert</a></td>
<td>指定元素存在与否断言</td>
</tr>
<tr>
<td><a href="#selfText_assert">selfText_assert</a></td>
<td>指定元素文本值断言</td>
</tr>
<tr>
<td><a href="#selfAttribute_assert">selfAttribute_assert</a></td>
<td>指定元素属性值断言</td>
</tr>
<tr>
<td><a href="#actionBuilder_Move">actionBuilder_Move</a></td>
<td>指定元素鼠标悬浮</td>
</tr>
<tr>
<td><a href="#actionBuilder_RightClick">actionBuilder_RightClick</a></td>
<td>指定元素鼠标右击</td>
</tr>
<tr>
<td><a href="#actionBuilder_DoubleClick">actionBuilder_DoubleClick</a></td>
<td>指定元素鼠标双击</td>
</tr>
<tr>
<td><a href="#keyBoard_Events">keyBoard_Events</a></td>
<td>指定元素键盘按键模拟</td>
</tr>
<tr>
<td><a href="#getElementText">getElementText</a></td>
<td>指定元素数据信息获取</td>
</tr>
</tbody>
</table>
<h2><a id="_192"></a>五、框架中支持在外部脚本中调用的变量、方法、装饰器</h2>
<blockquote>
<p>无论使用的是变量、方法、装饰器，均需要在使用之前通过 <code>from kdtest import xxx</code> 提前引入</p>
</blockquote>
<h3><a id="1__194"></a>1. 变量</h3>
<h4><a id="GSTORE__195"></a>GSTORE 全局共享数据参数</h4>
<p>该变量是一个<code>dict</code>字典类型的参数，通过键入不同的key键来获取指定参数值或者对象值，变量可使用的key键，以及对应值的使用示例如下所示：</p>
<ul>
<li><code>GSTORE['driver']</code>: 对应当前的driver驱动对象。<pre><code class="prism language-python">driver <span class="token operator">=</span> GSTORE<span class="token punctuation">[</span><span class="token string">'driver'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出driver对象</span>
driver<span class="token punctuation">.</span>find_element_by_id<span class="token punctuation">(</span>xx<span class="token punctuation">)</span><span class="token punctuation">.</span>click<span class="token punctuation">(</span><span class="token punctuation">)</span>  <span class="token comment"># 使用driver对象</span>
</code></pre>
</li>
<li><code>GSTORE['keyWord']</code>: 框架中的关键字对象。<pre><code class="prism language-python">driver <span class="token operator">=</span> GSTORE<span class="token punctuation">[</span><span class="token string">'keyWord'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyWord<span class="token punctuation">.</span>click_btn<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span><span class="token string">'xxx'</span><span class="token punctuation">)</span>  <span class="token comment"># 使用关键字对象</span>
</code></pre>
</li>
<li><code>GSTORE['START']['testCaseFile']</code>: 书写在参数配置文件中“parameters.json”的<code>testCaseFile</code>参数中的值，当前正在执行的用例文件信息。<pre><code class="prism language-python"><span class="token keyword">print</span><span class="token punctuation">(</span>GSTORE<span class="token punctuation">[</span><span class="token string">'START'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token string">'testCaseFile'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># [{'caseFilePath':'xxx','caseItem':['xxx','xxx']},{}...]</span>
</code></pre>
</li>
<li><code>GSTORE['START']['browser']</code>: 书写在参数配置文件中“parameters.json”的，当前选中的浏览器平台名称。<pre><code class="prism language-python"><span class="token keyword">print</span><span class="token punctuation">(</span>GSTORE<span class="token punctuation">[</span><span class="token string">'START'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token string">'browser'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># Chrom</span>
</code></pre>
</li>
<li><code>GSTORE['START']['url']</code>: 书写在参数配置文件中“parameters.json”的，当前被测系统的url地址。<pre><code class="prism language-python"><span class="token keyword">print</span><span class="token punctuation">(</span>GSTORE<span class="token punctuation">[</span><span class="token string">'START'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token string">'url'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># http://localhost/</span>
</code></pre>
</li>
<li><code>GSTORE['START']['implicitlyWait']</code>: 书写在参数配置文件中“parameters.json”的，设置的“隐式等待时间”。<pre><code class="prism language-python"><span class="token keyword">print</span><span class="token punctuation">(</span>GSTORE<span class="token punctuation">[</span><span class="token string">'START'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token string">'implicitlyWait'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 10</span>
</code></pre>
</li>
<li><code>GSTORE['START']['retrySwitch']</code>: 书写在参数配置文件中“parameters.json”的，用例出错重复执行开关状态。<pre><code class="prism language-python"><span class="token keyword">print</span><span class="token punctuation">(</span>GSTORE<span class="token punctuation">[</span><span class="token string">'START'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token string">'retrySwitch'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># False</span>
</code></pre>
</li>
<li><code>GSTORE['START']['selfDefinedParameter'][xxx]</code> : 书写在参数配置文件中“parameters.json”的，定义的自定义参数。<pre><code class="prism language-python"><span class="token comment"># 在参数配置文件中定义一个自定义参数名为userName，其值为admin</span>
<span class="token keyword">print</span><span class="token punctuation">(</span>GSTORE<span class="token punctuation">[</span><span class="token string">'START'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token string">'selfDefinedParameter'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token string">'userName'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># admin</span>
</code></pre>
</li>
</ul>
<h3><a id="2__232"></a>2. 方法</h3>
<h4><a id="INFO__233"></a>INFO() 日志打印方法</h4>
<p>通过该方法可以将一些自定义的信息打印到框架的“测试报告”和“运行日志”中</p>
<pre><code class="prism language-python">INFO<span class="token punctuation">(</span><span class="token string">'要打印的文本信息'</span><span class="token punctuation">)</span>
INFO<span class="token punctuation">(</span><span class="token number">123</span><span class="token punctuation">)</span>
</code></pre>
<h3><a id="3__239"></a>3. 装饰器</h3>
<h4><a id="reset_implicitlyWait__240"></a>reset_implicitlyWait 隐式等待时间重置装饰器</h4>
<blockquote>
<p>将当前框架中设置的“隐式等待时间”重置为指定的秒数, 调用结束后恢复</p>
</blockquote>
<p><strong>参数</strong><br>
必填，要进行重置的“隐式等待时间”，<code>int类型</code>代表秒数</p>
<p><strong>举例</strong></p>
<pre><code class="prism language-python"><span class="token keyword">from</span> kdtest <span class="token keyword">import</span> reset_implicitlyWait
<span class="token triple-quoted-string string">'''隐式等待时间重置'''</span>
<span class="token decorator annotation punctuation">@reset_implicitlyWait</span><span class="token punctuation">(</span><span class="token number">1</span><span class="token punctuation">)</span>  <span class="token comment"># 将当前框架中设置的“隐式等待时间”重置为1s, 函数调用结束后恢复</span>
<span class="token keyword">def</span> <span class="token function">test_functionOne</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">:</span>
    <span class="token keyword">pass</span>

<span class="token keyword">if</span> __name__ <span class="token operator">==</span> <span class="token string">"__main__"</span><span class="token punctuation">:</span>
    test_functionOne<span class="token punctuation">(</span><span class="token punctuation">)</span>
</code></pre>
<p><strong>执行流程示例</strong></p>
<div class="mermaid"><svg id="mermaid-svg-riEh3JkmL5eWBp0a" width="652.625" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" height="62" viewBox="0 0 652.625 62" class="mermaid-svg"><style>#mermaid-svg-riEh3JkmL5eWBp0a {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-riEh3JkmL5eWBp0a .error-icon{fill:#552222;}#mermaid-svg-riEh3JkmL5eWBp0a .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-riEh3JkmL5eWBp0a .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-riEh3JkmL5eWBp0a .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-riEh3JkmL5eWBp0a .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-riEh3JkmL5eWBp0a .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-riEh3JkmL5eWBp0a .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-riEh3JkmL5eWBp0a .marker{fill:#333333;stroke:#333333;}#mermaid-svg-riEh3JkmL5eWBp0a .marker.cross{stroke:#333333;}#mermaid-svg-riEh3JkmL5eWBp0a svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-riEh3JkmL5eWBp0a .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-riEh3JkmL5eWBp0a .cluster-label text{fill:#333;}#mermaid-svg-riEh3JkmL5eWBp0a .cluster-label span{color:#333;}#mermaid-svg-riEh3JkmL5eWBp0a .label text,#mermaid-svg-riEh3JkmL5eWBp0a span{fill:#333;color:#333;}#mermaid-svg-riEh3JkmL5eWBp0a .node rect,#mermaid-svg-riEh3JkmL5eWBp0a .node circle,#mermaid-svg-riEh3JkmL5eWBp0a .node ellipse,#mermaid-svg-riEh3JkmL5eWBp0a .node polygon,#mermaid-svg-riEh3JkmL5eWBp0a .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-riEh3JkmL5eWBp0a .node .label{text-align:center;}#mermaid-svg-riEh3JkmL5eWBp0a .node.clickable{cursor:pointer;}#mermaid-svg-riEh3JkmL5eWBp0a .arrowheadPath{fill:#333333;}#mermaid-svg-riEh3JkmL5eWBp0a .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-riEh3JkmL5eWBp0a .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-riEh3JkmL5eWBp0a .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-riEh3JkmL5eWBp0a .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-riEh3JkmL5eWBp0a .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-riEh3JkmL5eWBp0a .cluster text{fill:#333;}#mermaid-svg-riEh3JkmL5eWBp0a .cluster span{color:#333;}#mermaid-svg-riEh3JkmL5eWBp0a div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-riEh3JkmL5eWBp0a :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}</style><g><g class="output"><g class="clusters"></g><g class="edgePaths"><g class="edgePath LS-A LE-B" id="L-A-B" style="opacity: 1;"><path class="path" d="M186.875,31L191.04166666666666,31C195.20833333333334,31,203.54166666666666,31,211.875,31C220.20833333333334,31,228.54166666666666,31,232.70833333333334,31L236.875,31" marker-end="url(#arrowhead404)" style="fill:none"></path><defs><marker id="arrowhead404" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1; stroke-dasharray: 1, 0;"></path></marker></defs></g><g class="edgePath LS-B LE-C" style="opacity: 1;" id="L-B-C"><path class="path" d="M383.75,31L387.9166666666667,31C392.0833333333333,31,400.4166666666667,31,408.75,31C417.0833333333333,31,425.4166666666667,31,429.5833333333333,31L433.75,31" marker-end="url(#arrowhead405)" style="fill:none"></path><defs><marker id="arrowhead405" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1; stroke-dasharray: 1, 0;"></path></marker></defs></g></g><g class="edgeLabels"><g class="edgeLabel" transform="" style="opacity: 1;"><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0"></rect><foreignObject width="0" height="0"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; white-space: nowrap;"><span id="L-L-A-B" class="edgeLabel L-LS-A' L-LE-B"></span></div></foreignObject></g></g><g class="edgeLabel" style="opacity: 1;" transform=""><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0"></rect><foreignObject width="0" height="0"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; white-space: nowrap;"><span id="L-L-B-C" class="edgeLabel L-LS-B' L-LE-C"></span></div></foreignObject></g></g></g><g class="nodes"><g class="node default" id="flowchart-A-199" transform="translate(97.4375,31)" style="opacity: 1;"><rect rx="0" ry="0" x="-89.4375" y="-23" width="178.875" height="46" class="label-container"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-79.4375,-13)"><foreignObject width="158.875" height="26"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; white-space: nowrap;">方法调用前隐式时间5s</div></foreignObject></g></g></g><g class="node default" style="opacity: 1;" id="flowchart-B-200" transform="translate(310.3125,31)"><rect rx="0" ry="0" x="-73.4375" y="-23" width="146.875" height="46" class="label-container"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-63.4375,-13)"><foreignObject width="126.875" height="26"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; white-space: nowrap;">方法内隐式时间1s</div></foreignObject></g></g></g><g class="node default" style="opacity: 1;" id="flowchart-C-201" transform="translate(539.1875,31)"><rect rx="0" ry="0" x="-105.4375" y="-23" width="210.875" height="46" class="label-container"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-95.4375,-13)"><foreignObject width="190.875" height="26"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; white-space: nowrap;">方法调用结束后隐式时间5s</div></foreignObject></g></g></g></g></g></g></svg></div>
<hr>
<h4><a id="setInterval__263"></a>setInterval 全局定时器装饰器</h4>
<blockquote>
<p>对被装饰的方法进行循环执行，只不过“循环变量终值”和“循环步长值”都变成了秒数</p>
</blockquote>
<p><strong>参数</strong><br>
必填，要进行定时执行的“间隔时长”和“总时长”，均为<code>int类型</code>秒数</p>
<p><strong>举例</strong></p>
<pre><code class="prism language-python"><span class="token keyword">from</span> kdtest <span class="token keyword">import</span> setInterval
<span class="token triple-quoted-string string">'''全局定时器'''</span>
<span class="token decorator annotation punctuation">@setInterval</span><span class="token punctuation">(</span><span class="token number">2</span><span class="token punctuation">,</span><span class="token number">10</span><span class="token punctuation">)</span>   <span class="token comment"># 每2s执行一次，10s后结束执行</span>
<span class="token keyword">def</span> <span class="token function">test_functionTwo</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">:</span>
    <span class="token keyword">print</span><span class="token punctuation">(</span><span class="token string">"执行"</span><span class="token punctuation">)</span>

<span class="token keyword">if</span> __name__ <span class="token operator">==</span> <span class="token string">"__main__"</span><span class="token punctuation">:</span>
    test_functionTwo<span class="token punctuation">(</span><span class="token punctuation">)</span>
</code></pre>
<p><strong>执行流程示例</strong></p>
<div class="mermaid"><svg id="mermaid-svg-4hhzK5JtPPGF6dIu" width="346" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" height="171" viewBox="0 0 346 171" class="mermaid-svg"><style>#mermaid-svg-4hhzK5JtPPGF6dIu {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-4hhzK5JtPPGF6dIu .error-icon{fill:#552222;}#mermaid-svg-4hhzK5JtPPGF6dIu .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-4hhzK5JtPPGF6dIu .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-4hhzK5JtPPGF6dIu .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-4hhzK5JtPPGF6dIu .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-4hhzK5JtPPGF6dIu .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-4hhzK5JtPPGF6dIu .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-4hhzK5JtPPGF6dIu .marker{fill:#333333;stroke:#333333;}#mermaid-svg-4hhzK5JtPPGF6dIu .marker.cross{stroke:#333333;}#mermaid-svg-4hhzK5JtPPGF6dIu svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-4hhzK5JtPPGF6dIu .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-4hhzK5JtPPGF6dIu .cluster-label text{fill:#333;}#mermaid-svg-4hhzK5JtPPGF6dIu .cluster-label span{color:#333;}#mermaid-svg-4hhzK5JtPPGF6dIu .label text,#mermaid-svg-4hhzK5JtPPGF6dIu span{fill:#333;color:#333;}#mermaid-svg-4hhzK5JtPPGF6dIu .node rect,#mermaid-svg-4hhzK5JtPPGF6dIu .node circle,#mermaid-svg-4hhzK5JtPPGF6dIu .node ellipse,#mermaid-svg-4hhzK5JtPPGF6dIu .node polygon,#mermaid-svg-4hhzK5JtPPGF6dIu .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-4hhzK5JtPPGF6dIu .node .label{text-align:center;}#mermaid-svg-4hhzK5JtPPGF6dIu .node.clickable{cursor:pointer;}#mermaid-svg-4hhzK5JtPPGF6dIu .arrowheadPath{fill:#333333;}#mermaid-svg-4hhzK5JtPPGF6dIu .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-4hhzK5JtPPGF6dIu .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-4hhzK5JtPPGF6dIu .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-4hhzK5JtPPGF6dIu .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-4hhzK5JtPPGF6dIu .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-4hhzK5JtPPGF6dIu .cluster text{fill:#333;}#mermaid-svg-4hhzK5JtPPGF6dIu .cluster span{color:#333;}#mermaid-svg-4hhzK5JtPPGF6dIu div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-4hhzK5JtPPGF6dIu :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}</style><g><g class="output"><g class="clusters"></g><g class="edgePaths"><g class="edgePath LS-A LE-B" id="L-A-B" style="opacity: 1;"><path class="path" d="M92,50.1588785046729L102.83333333333333,45.299065420560744C113.66666666666667,40.4392523364486,135.33333333333334,30.7196261682243,157,27.88555834156472C178.66666666666666,25.05149051490515,200.33333333333334,29.102981029810298,211.16666666666666,31.128726287262875L222,33.15447154471545" marker-end="url(#arrowhead418)" style="fill:none"></path><defs><marker id="arrowhead418" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1; stroke-dasharray: 1, 0;"></path></marker></defs></g><g class="edgePath LS-B LE-A" style="opacity: 1;" id="L-B-A"><path class="path" d="M222,55.78861788617886L211.16666666666666,57.99051490514905C200.33333333333334,60.192411924119234,178.66666666666666,64.59620596205961,157,66.79810298102981C135.33333333333334,69,113.66666666666667,69,102.83333333333333,69L92,69" marker-end="url(#arrowhead419)" style="fill:none"></path><defs><marker id="arrowhead419" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1; stroke-dasharray: 1, 0;"></path></marker></defs></g><g class="edgePath LS-A LE-C" style="opacity: 1;" id="L-A-C"><path class="path" d="M84.66197183098592,92L96.71830985915494,100C108.77464788732395,108,132.88732394366198,124,158.443661971831,132C184,140,211,140,224.5,140L238,140" marker-end="url(#arrowhead420)" style="fill:none"></path><defs><marker id="arrowhead420" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1; stroke-dasharray: 1, 0;"></path></marker></defs></g></g><g class="edgeLabels"><g class="edgeLabel" transform="translate(157,21)" style="opacity: 1;"><g transform="translate(-16,-13)" class="label"><rect rx="0" ry="0" width="32" height="26"></rect><foreignObject width="32" height="26"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; white-space: nowrap;"><span id="L-L-A-B" class="edgeLabel L-LS-A' L-LE-B">循环</span></div></foreignObject></g></g><g class="edgeLabel" style="opacity: 1;" transform="translate(157,69)"><g transform="translate(-16,-13)" class="label"><rect rx="0" ry="0" width="32" height="26"></rect><foreignObject width="32" height="26"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; white-space: nowrap;"><span id="L-L-B-A" class="edgeLabel L-LS-B' L-LE-A">循环</span></div></foreignObject></g></g><g class="edgeLabel" style="opacity: 1;" transform="translate(157,140)"><g transform="translate(-40,-13)" class="label"><rect rx="0" ry="0" width="80" height="26"></rect><foreignObject width="80" height="26"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; white-space: nowrap;"><span id="L-L-A-C" class="edgeLabel L-LS-A' L-LE-C">总时长结束</span></div></foreignObject></g></g></g><g class="nodes"><g class="node default" id="flowchart-A-206" transform="translate(50,69)" style="opacity: 1;"><rect rx="0" ry="0" x="-42" y="-23" width="84" height="46" class="label-container"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-32,-13)"><foreignObject width="64" height="26"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; white-space: nowrap;">函数执行</div></foreignObject></g></g></g><g class="node default" style="opacity: 1;" id="flowchart-B-207" transform="translate(280,44)"><rect rx="0" ry="0" x="-58" y="-23" width="116" height="46" class="label-container"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-48,-13)"><foreignObject width="96" height="26"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; white-space: nowrap;">总时长未结束</div></foreignObject></g></g></g><g class="node default" style="opacity: 1;" id="flowchart-C-209" transform="translate(280,140)"><rect rx="0" ry="0" x="-42" y="-23" width="84" height="46" class="label-container"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-32,-13)"><foreignObject width="64" height="26"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; white-space: nowrap;">结束执行</div></foreignObject></g></g></g></g></g></g></svg></div>
<hr>
<h1><a id="_286"></a>测试用例相关的数据文件书写示例</h1>
<h2><a id="_287"></a>一、测试用例文件书写说明</h2>
<p>框架中的测试用例书写在Excel工作簿中，一个工作簿文件代表一个用例集合，工作簿中的一个sheet工作表代表一条测试用例，工作表中的一个单元行代表一条用例步骤；用例步骤是框架执行用例时的最小单位。<br>
目前框架支持两种用例书写格式，分别为“区分元素定位数据形式” 和 “不区分元素定位数据形式”；其各自的书写示例如下：</p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>xxx</td>
<td>xxx</td>
<td>xxx</td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>xxx</td>
<td>xxx</td>
<td>xxx</td>
<td>xxx</td>
</tr>
<tr>
<td></td>
<td>…</td>
<td>…</td>
<td>…</td>
<td>…</td>
<td>…</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>xxx</td>
<td>xxx</td>
<td>xxx</td>
<td>xxx</td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>xxx</td>
<td>xxx</td>
<td>xxx</td>
<td>xxx</td>
<td>xxx</td>
</tr>
<tr>
<td></td>
<td>…</td>
<td>…</td>
<td>…</td>
<td>…</td>
<td>…</td>
<td>…</td>
</tr>
</tbody>
</table><blockquote>
<p>元素定位数据区分与否，其实就是观察“元素定位数据”是否详细的书写在用例步骤中。另外框架在对书写方法进行识别时是以sheet工作表为单位的，也就是说在书写方式上每条用例之间是互相不影响的，你可以根据实际情况灵活选择每条用例的书写方式。</p>
</blockquote>
<blockquote>
<p>所谓 “元素定位数据” 就是关键字要操作的元素的定位信息 (定位方式+定位表达式+index索引…)，在“不区分元素定位数据”格式下，你可以根据实际需求在 “关键字” 和 “操作值” 两列之间添加新的列，个数不设限制，但仅允许在 “关键字” 和 “操作值” 两列之间添加，其它位置添加框架将无法识别。</p>
</blockquote>
<blockquote>
<p>若采用“不区分元素定位数据”格式书写用例，“关键字” 和 “操作值” 两列之间，各列的含义和位置顺序，需要视所调用关键字的形参顺序而言。</p>
</blockquote>
<blockquote>
<p>若采用“区分元素定位数据”格式书写用例，其“列数”和“列顺序”均是固定不可变动的，若随意增加“列”或者变更“列”的位置顺序，会导致框架无法识别。</p>
</blockquote>
<blockquote>
<p>在用例中，对字段名“序号、操作步骤、关键字”等你可以任意修改，但是不论采用何种格式书写用例，“用例名称 [第一列]、序号 [第二列]、操作步骤 [第三列]、关键字 [第四列]、操作值 [最后一列]”这几列的位置顺序不可变动。</p>
</blockquote>
<h2><a id="_311"></a>二、接口数据文件书写说明</h2>
<p>固定命名为“ InterfaceData.yaml ”</p>
<pre><code class="prism language-yaml"><span class="token key atrule">xxxx</span><span class="token punctuation">:</span>  <span class="token comment"># 自定义的接口名称</span>
  <span class="token key atrule">_PARAMETERS</span><span class="token punctuation">:</span>  <span class="token comment"># 接口基本数据</span>
    <span class="token key atrule">METHOD</span><span class="token punctuation">:</span> xxx  <span class="token comment"># 请求方式</span>
    <span class="token key atrule">URL</span><span class="token punctuation">:</span> xxxx/xxxx/xxxx  <span class="token comment"># 请求地址</span>
    <span class="token key atrule">HEADER</span><span class="token punctuation">:</span>  <span class="token comment"># 请求头</span>
      <span class="token key atrule">Content-Type</span><span class="token punctuation">:</span> application/x<span class="token punctuation">-</span>www<span class="token punctuation">-</span>form<span class="token punctuation">-</span>urlencoded
    <span class="token key atrule">PARAMS</span><span class="token punctuation">:</span>  <span class="token comment"># 接口请求参数(URL地址解析写法)</span>
      <span class="token key atrule">UNAME</span><span class="token punctuation">:</span> userName
      <span class="token key atrule">PASSWORD</span><span class="token punctuation">:</span> xx
      <span class="token key atrule">encode_type</span><span class="token punctuation">:</span> xx
    <span class="token key atrule">DATA</span><span class="token punctuation">:</span>  <span class="token comment"># 请求参数 data类型</span>
      <span class="token key atrule">UNAME</span><span class="token punctuation">:</span> userName
      <span class="token key atrule">PASSWORD</span><span class="token punctuation">:</span> xx
      <span class="token key atrule">encode_type</span><span class="token punctuation">:</span> xx
    <span class="token key atrule">FILE</span><span class="token punctuation">:</span>  <span class="token comment"># 文件</span>
      <span class="token key atrule">FILE_KEY</span><span class="token punctuation">:</span> <span class="token string">'file'</span>  <span class="token comment"># 参数key键[视实际接口为准]</span>
      <span class="token key atrule">NAME</span><span class="token punctuation">:</span> <span class="token string">'test1.jpeg'</span>  <span class="token comment"># 文件名</span>
      <span class="token key atrule">SRC</span><span class="token punctuation">:</span> <span class="token string">'D:\\xxx\\xxx\\xxx\\test1.jpeg'</span>  <span class="token comment"># 文件路径</span>
      <span class="token key atrule">TYPE</span><span class="token punctuation">:</span> <span class="token string">'image/jpeg'</span>  <span class="token comment"># 文件类别</span>
    <span class="token key atrule">I_CODE</span><span class="token punctuation">:</span> xxxx  <span class="token comment"># 接口请求参数编码</span>
    <span class="token key atrule">COOKIE</span><span class="token punctuation">:</span>  xxx  <span class="token comment"># 登录态</span>
    <span class="token key atrule">CALLBACK</span><span class="token punctuation">:</span> xxx <span class="token comment"># 接口回调数据缓存信息列表</span>
    <span class="token key atrule">REGULAR</span><span class="token punctuation">:</span> xxx <span class="token comment"># “接口响应结果”进行筛选的“正则表达式”</span>
  <span class="token key atrule">_RESULT</span><span class="token punctuation">:</span> xxxx  <span class="token comment"># 接口请求结果断言预期结果</span>
  <span class="token key atrule">_RS</span><span class="token punctuation">:</span> None  <span class="token comment"># 固定输入None，不做解释</span>
</code></pre>
<h3><a id="xxxx__340"></a>xxxx 接口名称</h3>
<p>固定书写格式：<code>n[int]_接口名称</code>；此处的“接口名称”前需要按照顺序填写阿拉伯数字；例如 “1_Login_Interface”</p>
<ul>
<li>示例<pre><code class="prism language-yaml"><span class="token key atrule">1/1_Login</span><span class="token punctuation">:</span>
  <span class="token key atrule">_PARAMETERS</span><span class="token punctuation">:</span>
  .
  .
  .
  <span class="token key atrule">_RESULT</span><span class="token punctuation">:</span> xxxx
  <span class="token key atrule">_RS</span><span class="token punctuation">:</span> None
  
<span class="token key atrule">1/2_get_information</span><span class="token punctuation">:</span>
  <span class="token key atrule">_PARAMETERS</span><span class="token punctuation">:</span>
  .
  .
  .
  <span class="token key atrule">_RESULT</span><span class="token punctuation">:</span> xxxx
  <span class="token key atrule">_RS</span><span class="token punctuation">:</span> None
  
<span class="token key atrule">2_set_information</span><span class="token punctuation">:</span>
  <span class="token key atrule">_PARAMETERS</span><span class="token punctuation">:</span>
  .
  .
  .
  <span class="token key atrule">_RESULT</span><span class="token punctuation">:</span> xxxx
  <span class="token key atrule">_RS</span><span class="token punctuation">:</span> None
</code></pre>
</li>
</ul>
<h3><a id="_PARAMETERS__368"></a>_PARAMETERS 请求参数集合</h3>
<p>该集合中并非是所有参数均需要填写，你需要根据实际的接口来确定书写那写参数项。</p>
<h4><a id="1_METHOD_370"></a>1. METHOD</h4>
<ul>
<li>请求类型  <code>POST</code>、<code>GET</code>、<code>PUT</code>、<code>PATCH</code> …
<blockquote>
<p>不区分大小写</p>
</blockquote>
</li>
<li>书写示例：[–yaml文件写法–]<pre><code class="prism language-yaml"><span class="token key atrule">METHOD</span><span class="token punctuation">:</span> POST
</code></pre>
</li>
</ul>
<h4><a id="2_URL_377"></a>2. URL</h4>
<ul>
<li>请求地址，系统前缀路径不必书写
<blockquote>
<p>示例：10.5.11.34/test/userLogin/submit.php<br>
书写为：test/userLogin/submit.php</p>
</blockquote>
</li>
<li>书写示例：[–yaml文件写法–]<pre><code class="prism language-yaml"><span class="token key atrule">URL</span><span class="token punctuation">:</span> test/userLogin/submit.php
</code></pre>
</li>
</ul>
<h4><a id="3_HEADER_385"></a>3. HEADER</h4>
<ul>
<li>请求头；参数为<code>dict 类型</code>，其子项均为固定项，需要根据接口进行填写</li>
<li>书写示例：[–yaml文件写法–]<pre><code class="prism language-yaml"><span class="token key atrule">HEADER</span><span class="token punctuation">:</span>
	<span class="token key atrule">Content-Type</span><span class="token punctuation">:</span> application/x<span class="token punctuation">-</span>www<span class="token punctuation">-</span>form<span class="token punctuation">-</span>urlencoded
</code></pre>
</li>
</ul>
<h4><a id="4_DATA_392"></a>4. DATA</h4>
<ul>
<li>接口请求参数；参数为<code>dict 类型</code>，根据不同的接口请求参数随之改变</li>
<li>书写示例：[–yaml文件写法–]<pre><code class="prism language-yaml"><span class="token key atrule">DATA</span><span class="token punctuation">:</span> 
   <span class="token key atrule">KEY1</span><span class="token punctuation">:</span> <span class="token string">"1"</span>  <span class="token comment"># 普通字符串</span>
   <span class="token key atrule">KEY2</span><span class="token punctuation">:</span>  <span class="token comment"># [12, 10] 列表</span>
       <span class="token punctuation">-</span> <span class="token number">12</span>
       <span class="token punctuation">-</span> <span class="token number">10</span> 
   <span class="token key atrule">KEY3</span><span class="token punctuation">:</span>  <span class="token comment"># {'NAME': "123", 'AGE': 12}  字典</span>
       <span class="token key atrule">NAME</span><span class="token punctuation">:</span> <span class="token string">"123"</span>
       <span class="token key atrule">AGE</span><span class="token punctuation">:</span> <span class="token number">12</span>
</code></pre>
</li>
</ul>
<h4><a id="5_PARAMS_405"></a>5. PARAMS</h4>
<ul>
<li>接口请求参数(URL地址解析写法)；参数为<code>dict 类型</code>，根据不同的接口请求参数随之改变</li>
<li>书写示例：[–yaml文件写法–]<pre><code class="prism language-yaml"><span class="token key atrule">PARAMS</span><span class="token punctuation">:</span> 
   <span class="token key atrule">KEY1</span><span class="token punctuation">:</span> <span class="token string">"1"</span>  <span class="token comment"># 普通字符串</span>
   <span class="token key atrule">KEY2</span><span class="token punctuation">:</span>  <span class="token comment"># [12, 10] 列表</span>
       <span class="token punctuation">-</span> <span class="token number">12</span>
       <span class="token punctuation">-</span> <span class="token number">10</span> 
   <span class="token key atrule">KEY3</span><span class="token punctuation">:</span>  <span class="token comment"># {'NAME': "123", 'AGE': 12}  字典</span>
       <span class="token key atrule">NAME</span><span class="token punctuation">:</span> <span class="token string">"123"</span>
       <span class="token key atrule">AGE</span><span class="token punctuation">:</span> <span class="token number">12</span>
</code></pre>
</li>
</ul>
<h4><a id="6_FILE_418"></a>6. FILE</h4>
<blockquote>
<p>注意使用此参数时，请求头<code>HEADER</code>应不书写，否则文件将无法上传成功</p>
</blockquote>
<ul>
<li>文件参数；参数为<code>dict 类型</code>，固定子项KEY书写为：<code>FFILE_KEY, NAME</code>，<code>SRC</code>，<code>TYPE</code>；功能迭代优化后支持多文件上传。</li>
<li>书写示例：[–yaml文件写法–]<pre><code class="prism language-yaml"><span class="token comment">#  单文件</span>
<span class="token key atrule">FILE</span><span class="token punctuation">:</span>
    <span class="token key atrule">FILE_KEY</span><span class="token punctuation">:</span> <span class="token string">'file'</span>  <span class="token comment"># 参数key键[视实际接口为准]</span>
    <span class="token key atrule">NAME</span><span class="token punctuation">:</span> <span class="token string">'test1.jpeg'</span>  <span class="token comment"># 文件名</span>
    <span class="token key atrule">SRC</span><span class="token punctuation">:</span> <span class="token string">'D:\\Program_code\\python\\Python_requests\\test1.jpeg'</span>  <span class="token comment"># 文件路径</span>
    <span class="token key atrule">TYPE</span><span class="token punctuation">:</span> <span class="token string">'image/jpeg'</span>  <span class="token comment"># 文件类别</span>

<span class="token comment"># 多文件,采用“列表list”嵌套“字典dict”形式</span>
<span class="token key atrule">FILE</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span> <span class="token key atrule">FILE_KEY</span><span class="token punctuation">:</span> <span class="token string">'file1'</span>  <span class="token comment"># 参数key键[视实际接口为准]</span>
    <span class="token key atrule">NAME</span><span class="token punctuation">:</span> <span class="token string">'test1.jpeg'</span>  <span class="token comment"># 文件名</span>
    <span class="token key atrule">SRC</span><span class="token punctuation">:</span> <span class="token string">'D:\\Program_code\\python\\Python_requests\\test1.jpeg'</span>  <span class="token comment"># 文件路径</span>
    <span class="token key atrule">TYPE</span><span class="token punctuation">:</span> <span class="token string">'image/jpeg'</span>  <span class="token comment"># 文件类别</span>

    <span class="token punctuation">-</span> <span class="token key atrule">FILE_KEY</span><span class="token punctuation">:</span> <span class="token string">'file2'</span>  <span class="token comment"># 参数key键[视实际接口为准]</span>
    <span class="token key atrule">NAME</span><span class="token punctuation">:</span> <span class="token string">'test2.jpeg'</span>  <span class="token comment"># 文件名</span>
    <span class="token key atrule">SRC</span><span class="token punctuation">:</span> <span class="token string">'D:\\Program_code\\python\\Python_requests\\test2.jpeg'</span>  <span class="token comment"># 文件路径</span>
    <span class="token key atrule">TYPE</span><span class="token punctuation">:</span> <span class="token string">'image/jpeg'</span>  <span class="token comment"># 文件类别</span>
</code></pre>
</li>
</ul>
<h4><a id="7_I_CODE_443"></a>7. I_CODE</h4>
<ul>
<li>接口请求参数编码；该参数用于为 DATA数据中的“中文参数”设置编码，以避免在传入接口后出现乱码的问题。</li>
<li>书写示例：[–yaml文件写法–]<pre><code class="prism language-yaml"><span class="token key atrule">I_CODE</span><span class="token punctuation">:</span> 'GB2312' <span class="token punctuation">|</span><span class="token punctuation">|</span> 'utf<span class="token punctuation">-</span>8'
</code></pre>
</li>
</ul>
<h4><a id="8_COOKIE_449"></a>8. COOKIE</h4>
<ul>
<li>登录态；该参数用于接收“系统登录态Cookie”值；如果想要使用“Cookie缓存文件“<code>Cookie.txt</code>”中的Cookie值(这里大多数为“登录接口”回调缓存)”，则只需要传入固定参数“ <code>CACHE</code> ”即可；如果想要使用自定义的Cookie值则根据Cookie参数传入dict字典即可。</li>
<li>书写示例：[–yaml文件写法–]<pre><code class="prism language-yaml"><span class="token comment"># 使用“缓存文件[Cookie.txt]中的Cookie” :</span>
<span class="token key atrule">COOKIE</span><span class="token punctuation">:</span> CACHE  <span class="token comment"># 【string类型】</span>

<span class="token comment"># 使用“自定义Cookie值” :</span>
<span class="token key atrule">COOKIE</span><span class="token punctuation">:</span>  <span class="token comment"># 【dict类型】</span>
    <span class="token key atrule">KEY1</span><span class="token punctuation">:</span> xxxx
    <span class="token key atrule">KEY2</span><span class="token punctuation">:</span> xxxx
</code></pre>
</li>
</ul>
<h4><a id="9_CALLBACK_461"></a>9. CALLBACK</h4>
<p>接口回调数据缓存信息列表；即将需要缓存的数据标注在[CALLBACK]列表中。该参数为<code>list 类型</code>，用于存放需要进行缓存的数据标识。规定参数值为三种 “<code>Cookie</code>”，“<code>A_Cookie</code>”，“<code>接口响应结果</code>”</p>
<ul>
<li>
<p>“<code>Cookie</code>”和“<code>A_Cookie</code>”为固定写法；二者都是对Cookies登录态进行缓存，不同的区别如下：</p>
<ul>
<li>“<code>Cookie</code>”会将“Cookie.txt”文件中的数据先清空，在将获取到的新数据写入文件中。</li>
<li>“<code>A_Cookie</code>” 不会清空“Cookie.txt”文件，它是将[Cookie.txt]文件中的数据进行一一判别，如果数据key存在则将其value值更新，如果数据key不存在则在文件中追加该键值对。</li>
</ul>
</li>
<li>
<p>“<code>接口响应结果</code>”写法分为两种[“json数据类型”，“非json数据类型”]，以下对“接口响应结果”的书写规则进行解释：</p>
<ul>
<li>“当响应结果为json数据类型时”：
<ul>
<li>写法不做限制，可以理解为 “缓存数据在缓存文件[Response_result.txt]”中的key键ID。在后续数据访问时通过此“key键”进行访问。</li>
<li>示例:</li>
</ul>
<pre><code class="prism language-yaml">	<span class="token key atrule">CALLBACK</span><span class="token punctuation">:</span>
		<span class="token punctuation">-</span> 自定义的ID
</code></pre>
</li>
<li>“当响应结果为非json数据类型时”：
<ul>
<li>书写格式：</li>
</ul>
<pre><code class="prism language-yaml">	<span class="token key atrule">CALLBACK</span><span class="token punctuation">:</span>
		<span class="token punctuation">-</span> <span class="token punctuation">-</span> <span class="token key atrule">ID</span><span class="token punctuation">:</span> xxx
			<span class="token key atrule">REGULAR</span><span class="token punctuation">:</span> 正则表达式
		  <span class="token punctuation">-</span> <span class="token key atrule">ID</span><span class="token punctuation">:</span> xxx
			<span class="token key atrule">REGULAR</span><span class="token punctuation">:</span> 正则表达式
</code></pre>
<ul>
<li>格式说明：此种写法是为了更好的对响应结果进行数据筛选；它可以将一个“接口响应接口”进行指定次数的“正则表达式筛选”和“缓存”</li>
<li>子项key解释：ID[缓存数据在缓存文件[Response_result.txt]”中的key键ID]，REGULAR[要进行数据筛选的“正则表达式”]</li>
</ul>
</li>
</ul>
<blockquote>
<p>注：不管“接口响应数据”类型是否为json；如果需要对“接口响应结果”进行数据缓存则在 CALLBACK 参数中必须要指明“接口响应结果数据指定ID”；否则会对数据读取产生影响。</p>
</blockquote>
</li>
</ul>
<p><strong>书写示例：[–yaml文件写法–]</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># “json类型”</span>
<span class="token key atrule">CALLBACK</span><span class="token punctuation">:</span> 
<span class="token punctuation">-</span> Cookie  <span class="token comment"># 缓存cookie</span>
<span class="token punctuation">-</span> 自定义ID

<span class="token comment"># “非json类型”</span>
<span class="token key atrule">CALLBACK</span><span class="token punctuation">:</span>
<span class="token punctuation">-</span> Cookie  <span class="token comment"># 缓存cookie</span>
<span class="token punctuation">-</span> <span class="token punctuation">-</span> <span class="token key atrule">ID</span><span class="token punctuation">:</span> XXX
    <span class="token key atrule">REGULAR</span><span class="token punctuation">:</span> XXX
  <span class="token punctuation">-</span> <span class="token key atrule">ID</span><span class="token punctuation">:</span> XXX
    <span class="token key atrule">REGULAR</span><span class="token punctuation">:</span> XXX
</code></pre>
<p><strong>举例说明</strong></p>
<ul>
<li>假设“A接口”请求需要保存其回调数据中的Cookie值，则在接口数据中“A接口的CALLBACK”参数书写为：<pre><code class="prism language-yaml"><span class="token key atrule">CALLBACK</span><span class="token punctuation">:</span>
	<span class="token punctuation">-</span> Cookie
</code></pre>
</li>
<li>假设“B接口”的请求需要保存其回调数据中的“接口响应结果”，则在接口数据中“B接口的CALLBACK”参数书写为：<pre><code class="prism language-yaml"><span class="token key atrule">CALLBACK</span><span class="token punctuation">:</span>
	<span class="token punctuation">-</span> B_KEYID  <span class="token comment"># 此处为举例，名称随意不重复即可</span>
</code></pre>
<blockquote>
<p>此时“响应结果缓存文件[Response_result.txt]”中的数据为：{‘B_KEYID’: “B接口响应结果”}<br>
{‘B_KEYID’: {‘name’:“wangming”, ‘age’:18}[此处为举例，用于“假设3”]}</p>
</blockquote>
</li>
<li>假设“C接口”请求需要使用“B接口”响应结果中的某个值来作为“C接口的请求参数”，则在接口数据文件[InterfaceData.yaml]中“C接口的DATA”参数书写为：<pre><code class="prism language-yaml"><span class="token key atrule">DATA</span><span class="token punctuation">:</span>
	NAME<span class="token punctuation">[</span>举例，需要参照接口书写<span class="token punctuation">]</span><span class="token punctuation">:</span> CACHE<span class="token punctuation">[</span><span class="token string">'B_KEYID'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token string">'name'</span><span class="token punctuation">]</span>
    AGE<span class="token punctuation">[</span>举例，需要参照接口书写<span class="token punctuation">]</span><span class="token punctuation">:</span> CACHE<span class="token punctuation">[</span><span class="token string">'B_KEYID'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token string">'age'</span><span class="token punctuation">]</span>
<span class="token comment"># 解释：</span>
   <span class="token comment"># “CACHE” 固定写法代表要使用“响应结果缓存文件[Response_result.txt]”中的缓存数据</span>
   <span class="token comment"># “B_KEYID” 在“B接口”的“CALLBACK参数”中指定</span>
   <span class="token comment"># “name” 响应结果中的key需要参照实际响应结果书写</span>
</code></pre>
</li>
</ul>
<h4><a id="9_REGULAR_526"></a>9. REGULAR</h4>
<ul>
<li>对“接口响应结果”进行筛选的“正则表达式”；<code>string 类型</code>不做规定格式限制，如果该项为空[None]则代表不对“接口响应结果”进行筛选原样返还。但要确保传入的值是有效的“正则表达式”否则会出现异常问题</li>
<li>书写示例：[–yaml文件写法–]<pre><code class="prism language-yaml"><span class="token key atrule">REGULAR</span><span class="token punctuation">:</span> <span class="token string">'[\u4e00-\u9fa5]+'</span>  <span class="token comment"># 筛选所有汉字文本</span>
</code></pre>
<blockquote>
<p>注意：<br>
1、此处正则表达式为举例，需要参照实际情况的需要书写。<br>
2、该参数项只有在“接口响应结果”为非json数据时才会生效。</p>
</blockquote>
</li>
</ul>
<h3><a id="_RESULT__535"></a>_RESULT 请求结果断言预期比对值</h3>
<p>目前支持处理的接口响应结果为两种：“json类型”、“HTML 类型”</p>
<ul>
<li>
<p>如果“接口响应结果”为JSON类型，则在进行“_RESULT”参数填写时为：</p>
<pre><code class="prism language-yaml"> <span class="token key atrule">_RESULT</span><span class="token punctuation">:</span> 
      <span class="token key atrule">status</span><span class="token punctuation">:</span> SUCCESS <span class="token punctuation">[</span>举例，需要参照实际“接口响应结果数据”填写<span class="token punctuation">]</span>
      <span class="token key atrule">msg</span><span class="token punctuation">:</span> 上传成功！<span class="token punctuation">[</span>举例，需要参照实际“接口响应结果数据”填写<span class="token punctuation">]</span>
      <span class="token punctuation">...</span>..
</code></pre>
<blockquote>
<p>注：在“接口响应结果”为JSON类型时，脚本可支持“响应结果多参数判断”</p>
</blockquote>
</li>
<li>
<p>如果““接口响应结果”为HTML类型”,则在进行“_RESULT”参数填写时为：</p>
<pre><code class="prism language-yaml"><span class="token key atrule">_RESULT</span><span class="token punctuation">:</span> 系统登录正在进入系统请稍候 
</code></pre>
<blockquote>
<p>注：在“接口响应结果”为HTML类型时，脚本会对结果进行“正则表达式筛选”将所有汉字内容筛选出来<br>
例如：“&lt;/div class=big1&gt;正在进入OA系统，请稍候…&lt;/div/&gt;” 筛选完成后： “正在进入系统请稍候”</p>
</blockquote>
</li>
</ul>
<h3><a id="_RS__552"></a>_RS 执行状态</h3>
<ul>
<li>固定输入None，不做解释</li>
</ul>
<h2><a id="_554"></a>三、元素节点数据文件书写格式说明</h2>
<p>固定命名为“ elementData.yaml ”</p>
<pre><code class="prism language-yaml"><span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span> css_selectors  <span class="token comment"># 定位方式</span>
    <span class="token punctuation">-</span> xxx  <span class="token comment"># 定位表达式</span>
    <span class="token punctuation">-</span> <span class="token number">0</span>  <span class="token comment"># index索引</span>
  <span class="token key atrule">key3</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span> id  <span class="token comment"># 定位方式</span>
    <span class="token punctuation">-</span> xxx <span class="token comment"># 定位表达式</span>
  <span class="token key atrule">key4</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span> ids  <span class="token comment"># 定位方式</span>
    <span class="token punctuation">-</span> xxx <span class="token comment"># 定位表达式</span>
<span class="token key atrule">key2</span><span class="token punctuation">:</span>
  <span class="token key atrule">key1</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span> css_selectors  <span class="token comment"># 定位方式</span>
    <span class="token punctuation">-</span> xxx  <span class="token comment"># 定位表达式</span>
    <span class="token punctuation">-</span> <span class="token number">0</span>  <span class="token comment"># index索引</span>
</code></pre>
<ul>
<li>定位方式：框架中支持即可</li>
<li>定位表达式：应用定位方式对应，语法与selenium库一致</li>
<li>定位索引，只有在“复数定位”时生效</li>
</ul>
<blockquote>
<p>key+n：没有命名限制，同级之间不重复即可<br>
定位方式、定位表达式、位置索引三者之间的位置关系，需要视所调用关键字的形参顺序而言</p>
</blockquote>
<h1><a id="kdtest__579"></a>kdtest 框架可用关键字说明</h1>
<p>关键字含义：框架中已定义和编写好用来完成某项操作的，且可以在基于框架书写的测试用例和自定义插件中调用的方法函数称为关键字。</p>
<p>目前框架中共的关键字可分为两种分别为“框架原生关键字方法 <code>page_Action</code>”和“框架自定义插件方法 <code>plugins</code>”；<strong>框架原生关键字方法</strong> 主要是完成一些比较基础的操作如“点击”、“输入”、“断言”等等；<strong>框架自定义插件方法</strong> 则需要使用者根据实际被测系统进行书写，书写完毕后在将其安装到框架中即可使用。</p>
<blockquote>
<p>框架自定义插件方法的设计初衷是为了让框架的使用者能够根据实际的被测系统来书写对应的操作方法，这可以让框架在使用时更加灵活；框架中的所有原生关键字均支持在自定义的插件方法中使用，且自定义插件方法的编写不受任何限制，编写者完全可以根据自身的喜好来选择怎么书写它们；具体的书写规则和使用说明见文章《kdtest框架介绍》</p>
</blockquote>
<h2><a id="_auxiliary_585"></a>一、框架辅助关键字方法 (auxiliary)</h2>
<p>此类方法仅允许在脚本中调用，在用例中使用框架将无法识别；主要应用在“自动插件方法”的开发中，起辅助作用。</p>
<h3><a id="1element_index__587"></a>1、element_index() 关键字</h3>
<blockquote>
<p>索引位置标识转换</p>
</blockquote>
<p><strong>描述</strong><br>
返回指定的“位置标识”在实际元素列表中的位置索引(0 - n)；返回值类型为<code>int</code></p>
<blockquote>
<p>位置标识：<code>last</code>对应元素列表最后一项，<code>center</code>对应元素列表索引位置折中项</p>
</blockquote>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>复数定位方式, 定位表达式</td>
<td>位置标识</td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>element_index<span class="token punctuation">(</span><span class="token string">'复数定位方式'</span><span class="token punctuation">,</span> <span class="token string">'定位表达式'</span><span class="token punctuation">,</span> <span class="token string">'位置标识'</span><span class="token punctuation">)</span>  <span class="token comment"># 位置标识转换</span>

<span class="token comment"># 实例一</span>
index <span class="token operator">=</span> keyword<span class="token punctuation">.</span>element_index<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> <span class="token string">'last'</span><span class="token punctuation">)</span>  <span class="token comment"># 获取页面中id值为kw的所有元素中的最后一项的索引值</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>在使用关键字时所传入的元素定位信息应为“复数定位”(定位方式末尾带有‘s’时为复数定位)且不允许使用索引值，若传入“单元素定位”关键字将会报错。</li>
<li>关键字的返回结果为int类型的阿拉伯数字。</li>
<li>关键字所有参数均为必填项。</li>
</ul>
<hr>
<h3><a id="2locator__615"></a>2、locator() 关键字</h3>
<blockquote>
<p>元素定位 - 单元素</p>
</blockquote>
<p><strong>描述</strong><br>
根据传入的定位方式+定位表达式，找到并返回该元素；返回值类型为<code>elementObject</code></p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>单元素定位方式, 定位表达式</td>
<td>无参</td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>locator<span class="token punctuation">(</span><span class="token string">'单元素定位方式'</span><span class="token punctuation">,</span> <span class="token string">'定位表达式'</span><span class="token punctuation">)</span>  <span class="token comment"># 元素定位</span>

<span class="token comment"># 实例一</span>
element <span class="token operator">=</span> keyword<span class="token punctuation">.</span>locator<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">)</span>  <span class="token comment"># 定位id值为kw的元素</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字仅支持对单元素定位，无法识别复数定位方式。</li>
<li>关键字的返回结果为elementObject，返回值可直接操作。</li>
<li>关键字所有参数均为必填项。</li>
</ul>
<hr>
<h3><a id="3locators__642"></a>3、locators() 关键字</h3>
<blockquote>
<p>元素定位 - 复数元素</p>
</blockquote>
<p><strong>描述</strong><br>
根据传入的定位方式+定位表达式，找到并返回该元素；返回值类型为<code>list</code></p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>复数定位方式, 定位表达式[, 索引位置]</td>
<td>无参</td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>locators<span class="token punctuation">(</span><span class="token string">'复数定位方式'</span><span class="token punctuation">,</span> <span class="token string">'定位表达式'</span><span class="token punctuation">[</span><span class="token punctuation">,</span><span class="token string">'索引位置'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 元素定位</span>

<span class="token comment"># 实例一</span>
elements <span class="token operator">=</span> keyword<span class="token punctuation">.</span>locators<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">)</span>  <span class="token comment"># 定位id值为kw的所有元素</span>

<span class="token comment"># 实例二</span>
element <span class="token operator">=</span> keyword<span class="token punctuation">.</span>locators<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> <span class="token number">0</span><span class="token punctuation">)</span>  <span class="token comment"># 定位id值为kw的所有元素中的第一项</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字仅支持对复数元素定位，无法识别单元素定位方式。</li>
<li>关键字的返回结果为list列表，列表子项为elementObject，返回值列表子项可直接操作。</li>
<li><code>index 索引形参</code>不支持使用“索引位置标识”。</li>
<li>除<code>index 索引形参</code>外，关键字其它参数均为必填项。</li>
</ul>
<hr>
<h3><a id="4offLocator__673"></a>4、offLocator() 关键字</h3>
<blockquote>
<p>元素定位 - 后代元素</p>
</blockquote>
<p><strong>描述</strong><br>
根据传入的定位数据(支持处理“复数定位”和“单元素定位”)，找到并返回该元素；返回值类型为<code>elementObject</code></p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>定位方式, 定位表达式, 父级元素对象[, 索引值]</td>
<td>无参</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>offLocator<span class="token punctuation">(</span><span class="token string">'父级元素对象'</span><span class="token punctuation">,</span> <span class="token string">'定位方式'</span><span class="token punctuation">,</span> <span class="token string">'定位表达式'</span><span class="token punctuation">[</span><span class="token punctuation">,</span><span class="token string">'索引值'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 元素定位</span>

<span class="token comment"># 实例一</span>
elemetnObject <span class="token operator">=</span> keyword<span class="token punctuation">.</span>locator<span class="token punctuation">(</span><span class="token string">'tag_name'</span><span class="token punctuation">,</span> <span class="token string">'body'</span><span class="token punctuation">)</span>
element <span class="token operator">=</span> keyword<span class="token punctuation">.</span>offLocator<span class="token punctuation">(</span>elemetnObject<span class="token punctuation">,</span> <span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">)</span>  <span class="token comment"># 定位body标签下的id值为kw的元素</span>

<span class="token comment"># 实例二</span>
elemetnObject <span class="token operator">=</span> keyword<span class="token punctuation">.</span>locator<span class="token punctuation">(</span><span class="token string">'tag_name'</span><span class="token punctuation">,</span> <span class="token string">'body'</span><span class="token punctuation">)</span>
element <span class="token operator">=</span> keyword<span class="token punctuation">.</span>offLocator<span class="token punctuation">(</span>elemetnObject<span class="token punctuation">,</span> <span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">)</span>  <span class="token comment"># 定位body标签下的所有id值为kw的元素中的第一项</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字对定位方式不做限制，“复数定位”、“单元素定位”均支持。</li>
<li>若使用关键字进行“后代单元素定位”，<code>index 索引形参</code>不参与处理是否书写均可。</li>
<li>若使用关键字进行“后代复数元素定位”，<code>index 索引形参</code>为必填项，且不支持使用“索引位置标识”。</li>
<li>除<code>index 索引形参</code>外，关键字其它参数均为必填项。</li>
</ul>
<hr>
<h3><a id="5location_ScreenOperation__707"></a>5、location_ScreenOperation() 关键字</h3>
<blockquote>
<p>元素筛选定位</p>
</blockquote>
<p><strong>描述</strong><br>
根据传入的定位数据(支持处理“复数定位”和“单元素定位”)，找到并返回该元素；返回值类型为<code>elementObject</code></p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>定位方式, 定位表达式,[, 索引值][,父级元素对象]</td>
<td>无参</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>location_ScreenOperation<span class="token punctuation">(</span><span class="token string">'定位方式'</span><span class="token punctuation">,</span> <span class="token string">'定位表达式'</span><span class="token punctuation">[</span><span class="token punctuation">,</span><span class="token string">'索引值'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token punctuation">,</span><span class="token string">'父级元素对象'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 元素筛选定位</span>

<span class="token comment"># 实例一</span>
element <span class="token operator">=</span> keyword<span class="token punctuation">.</span>location_ScreenOperation<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">)</span>  <span class="token comment"># 定位id值为kw的元素</span>

<span class="token comment"># 实例二</span>
element <span class="token operator">=</span> keyword<span class="token punctuation">.</span>location_ScreenOperation<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">)</span>  <span class="token comment"># 定位id值为kw的所有元素中的第一项</span>

<span class="token comment"># 实例三</span>
element <span class="token operator">=</span> keyword<span class="token punctuation">.</span>location_ScreenOperation<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> <span class="token number">1</span><span class="token punctuation">)</span>  <span class="token comment"># 定位id值为kw的所有元素中的第二项</span>

<span class="token comment"># 实例四</span>
elemetnObject <span class="token operator">=</span> keyword<span class="token punctuation">.</span>locator<span class="token punctuation">(</span><span class="token string">'tag_name'</span><span class="token punctuation">,</span> <span class="token string">'body'</span><span class="token punctuation">)</span>
elements <span class="token operator">=</span> keyword<span class="token punctuation">.</span>location_ScreenOperation<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> ParentObject<span class="token operator">=</span>elemetnObject<span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">)</span>  <span class="token comment"># 定位body标签下的所有id值为kw的元素中的第一项</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字对定位方式不做限制，“复数定位”、“单元素定位”均支持。</li>
<li>关键字支持对“后代元素定位”。</li>
<li>若使用关键字进行“单元素定位”或者“后代单元素定位”，<code>index 索引形参</code>不参与处理是否书写均可。</li>
<li>若使用关键字进行“后代复数元素定位”，<code>index 索引形参</code>为必填项，且不支持使用“索引位置标识”。</li>
<li>若使用关键字进行“复数元素定位”，<code>index 索引形参</code>支持使用“索引位置标识”；若<code>index 索引形参</code>为空或者不合法，关键字默认取定位列表中索引位置为0的元素。</li>
</ul>
<hr>
<h2><a id="_page_Action_748"></a>二、框架原生关键字方法 (page_Action)</h2>
<p>在下文对各关键字的解释中频繁提到的 “<strong>用例步骤使用示例</strong>” 指的是关键字在用例文件中的使用方式和传参规则。另外在对每个关键字进行举例时，会对目前框架支持的两种用例书写方式分别做书写示例。</p>
<h3><a id="_750"></a>基础</h3>
<h4><a id="time_sleep__751"></a>time_sleep() 关键字</h4>
<blockquote>
<p>根据传入的秒数进行强制时间等待</p>
</blockquote>
<p><strong>描述</strong><br>
强制时间等待</p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>无参</td>
<td>非负数阿拉伯数字(0 - n 代表要停留的秒数)</td>
</tr>
</tbody>
</table><p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>time_sleep</td>
<td></td>
<td>5</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>time_sleep</td>
<td></td>
<td></td>
<td>5</td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>time_sleep<span class="token punctuation">(</span><span class="token number">10</span><span class="token punctuation">)</span>  <span class="token comment"># 强制时间等待10s</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>传入的操作值你只要确定其为阿拉伯数字即可，不必在意它的类型，在关键字中会进行类型转换。</li>
<li>强制时间等待关键字不需要传入“元素定位信息”，对应的元素定位单元格为空即可。</li>
<li>你传入的操作值在关键字中会被识别为“秒s”，例如传入“5”则代表暂停5秒在执行之后的操作。</li>
<li>该关键字一般用在执行完某个操作，需要等待被测系统做出反应之后在进行操作的情况。例如 “发送完成一封邮件后等待系统接收”、“删除某个人员等待系统加载”等等。</li>
</ul>
<hr>
<h4><a id="implicitly_time__785"></a>implicitly_time() 关键字</h4>
<blockquote>
<p>根据传入的秒数进行隐式时间等待 (一个driver对象只有一个隐式时间可以生效，按照顺序最近一次设置为有效，其它不生效)</p>
</blockquote>
<p><strong>描述</strong><br>
隐式时间等待</p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>无参</td>
<td>非负数阿拉伯数字(0 - n 代表要等待元素查找的秒数上限)</td>
</tr>
</tbody>
</table><p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>implicitly_time</td>
<td></td>
<td>10</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>implicitly_time</td>
<td></td>
<td></td>
<td>10</td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>implicitly_time<span class="token punctuation">(</span><span class="token number">20</span><span class="token punctuation">)</span>  <span class="token comment"># 设置隐式等待时长20s</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>传入的操作值你只要确定其为阿拉伯数字即可，不必在意它的类型，在关键字中会进行类型转换。</li>
<li>隐式时间等待关键字不需要传入“元素定位信息”，对应的元素定位单元格为空即可。</li>
<li>需要你注意一个driver对象只有一个隐式时间可以生效，按照顺序最近一次设置为有效，其它不生效。</li>
<li>设置的隐式时间为全局生效，所以在调用该关键字后整个框架的隐式等待时间均会改变。</li>
<li>该关键字实际应用的场景并不多，只有在你认为框架默认的隐式等待时间过短或者过长，可能会影响用例执行结果的准确度时可使用该关键字进行修改(框架默认的隐式等待时间为10s，该默认值可在启动参数中设置)。</li>
</ul>
<hr>
<h4><a id="explain__820"></a>explain() 关键字</h4>
<blockquote>
<p>在测试报告和测试日志中打印指定的内容</p>
</blockquote>
<p><strong>描述</strong><br>
无实际意义，只是用于将指定的内容打印在框架的测试报告和运行日志中</p>
<p><strong>参数</strong><br>
(特殊，见关键字注意事项)</p>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>要打印的文本</td>
<td>explain</td>
<td></td>
<td></td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>要打印的文本</td>
<td>explain</td>
<td></td>
<td></td>
<td></td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>explain<span class="token punctuation">(</span><span class="token string">"要打印的文本内容"</span><span class="token punctuation">)</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字所打印的内容信息为“操作步骤”单元格中的值，并非“操作值”单元格中的值</li>
<li>关键字主要负责将用例文件中的信息打印到运行日志和测试报告中，与脚本方法中的INFO()同等</li>
<li>关键字本身没有任何逻辑操作，故它不需要给“元素定位信息”和“操作值”单元格赋值</li>
</ul>
<hr>
<h3><a id="iframe_851"></a>iframe处理</h3>
<h4><a id="frame_default__852"></a>frame_default() 关键字</h4>
<blockquote>
<p>初始化当前活动窗口的frame焦点</p>
</blockquote>
<p><strong>描述</strong><br>
将当前拥有句柄的窗口中的iframe焦点还原到初始状态</p>
<blockquote>
<p>iframe焦点：移入到<strong>iframe页面</strong>中的操作焦点(selenium焦点)<br>
iframe页面：通过 html中的<code>&lt;iframe&gt;&lt;/iframe&gt;</code>标签嵌入到窗口中的页面</p>
</blockquote>
<p><strong>参数</strong><br>
无参</p>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>frame_default</td>
<td></td>
<td></td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>frame_default</td>
<td></td>
<td></td>
<td></td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>frame_default<span class="token punctuation">(</span><span class="token punctuation">)</span>  <span class="token comment"># iframe焦点初始化</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字会将当前活动窗口中的iframe焦点还原到最初始状态(即焦点不进入任何iframe标签内)，不论你是否进行过iframe焦点跳转。</li>
<li>关键字主要应用于页面结构较为复杂或者多层ifram嵌套使用的场景下，例如“进行人员删除前需要先进入一个三级嵌套的iframe页面中获取到人员的基础信息，之后在回到最外层点击删除按钮”。</li>
<li>关键字本身没有任何逻辑操作，故它不需要给“元素定位信息”和“操作值”单元格赋值。</li>
</ul>
<hr>
<h4><a id="parent_frame__885"></a>parent_frame() 关键字</h4>
<blockquote>
<p>将当前活动窗口中的iframe焦点向上跳转一级</p>
</blockquote>
<p><strong>描述</strong><br>
将当前拥有句柄的窗口中的iframe焦点向上跳转一层级，主要应用在iframe页面嵌套的情况下</p>
<blockquote>
<p>iframe1页面 → iframe1.1页面 → iframe1.1.1页面  （←为向上，→为向下）</p>
<blockquote>
<p>iframe焦点：移入到<strong>iframe页面</strong>中的操作焦点(selenium焦点)<br>
iframe页面：通过 html中的<code>&lt;iframe&gt;&lt;/iframe&gt;</code>标签嵌入到窗口中的页面</p>
</blockquote>
</blockquote>
<p><strong>参数</strong><br>
无参</p>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>parent_frame</td>
<td></td>
<td></td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>parent_frame</td>
<td></td>
<td></td>
<td></td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>parent_frame<span class="token punctuation">(</span><span class="token punctuation">)</span>  <span class="token comment"># iframe焦点向上跳转一级</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>与frame_default关键字类似，只不过前者是跳出所有而parent_frame关键字是向上跳出一级。</li>
<li>关键字的操作类似于文件夹目录结构的跳转，架设现在页面是一个三级嵌套的iframe页面，当前的iframe焦点在第三层，使用关键字后焦点会跳转至第二层。</li>
<li>该关键字能够灵活在iframe层级间跳转，适用于需要频繁切换或者涉及到iframe焦点上下切换的场景中。</li>
<li>关键字本身没有任何逻辑操作，故它不需要给“元素定位信息”和“操作值”单元格赋值。</li>
</ul>
<hr>
<h4><a id="refresh_frame__920"></a>refresh_frame() 关键字</h4>
<blockquote>
<p>刷新当前拥有焦点的iframe页面</p>
<blockquote>
<p>框架1.1.4版本新增</p>
</blockquote>
</blockquote>
<p><strong>描述</strong><br>
将当前拥有焦点的iframe页面刷新，注意此处刷新的并非窗口而是窗口中的iframe页面</p>
<blockquote>
<p>iframe焦点：移入到<strong>iframe页面</strong>中的操作焦点(selenium焦点)<br>
iframe页面：通过 html中的<code>&lt;iframe&gt;&lt;/iframe&gt;</code>标签嵌入到窗口中的页面</p>
</blockquote>
<p><strong>参数</strong><br>
无参</p>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>refresh_frame</td>
<td></td>
<td></td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>refresh_frame</td>
<td></td>
<td></td>
<td></td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>refresh_frame<span class="token punctuation">(</span><span class="token punctuation">)</span>  <span class="token comment"># 当前iframe页面刷新</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>注意与 <code>driver_refres()</code> 关键字的区别，前者是将拥有句柄的整个浏览器窗口包括iframe页面全部刷新，而后者则仅是刷新当前拥有焦点的iframe页面。</li>
<li>关键字本身没有任何逻辑操作，故它不需要给“元素定位信息”和“操作值”单元格赋值。</li>
</ul>
<hr>
<h4><a id="switch_frame__953"></a>switch_frame() 关键字</h4>
<blockquote>
<p>根据指定的iframe标识，进行iframe焦点跳转</p>
</blockquote>
<p><strong>描述</strong><br>
将操作焦点跳转到指定的iframe页面中</p>
<blockquote>
<p>iframe页面：通过 html中的<code>&lt;iframe&gt;&lt;/iframe&gt;</code>标签嵌入到窗口中的页面</p>
</blockquote>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>无参</td>
<td>iframe标签ID属性值 / iframe标签在窗口中索引位置(索引从0开始)</td>
</tr>
</tbody>
</table><p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>switch_frame</td>
<td></td>
<td>id / index</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>switch_frame</td>
<td></td>
<td></td>
<td>id / index</td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>switch_frame<span class="token punctuation">(</span><span class="token builtin">id</span> <span class="token operator">|</span><span class="token operator">|</span> index<span class="token punctuation">)</span>  <span class="token comment"># 焦点跳转到iframe中</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字用于将焦点跳转到指定的iframe页面中，已达到获取或者操作指定iframe页面中元素的目的。</li>
<li>关键字并不能支持一次性多级跳转，假设当前页面是一个两级嵌套的iframe页面，如果想要跳转到最底层的iframe页面中，你需要一级一级的调用它完成跳转，直接跳转到最底层会出现错误。</li>
<li>操作值中的“id” 代表指定页面所在的iframe标签的id属性值，关键字可根据它完成跳转。</li>
<li>操作值中的“index” 代表指定页面所在iframe标签在整个页面中的索引位置(起始为0)，在iframe标签不存在id属性的情况下关键字可根据它完成跳转。</li>
<li>同样如果使用index索引值进行定位，你不必在意它是否为数值类型的数字，关键字会自行转换。</li>
<li>注意关键字对iframe标签的定位采用的是“操作值”单元格中的id或者index索引值，并不是“元素定位信息”，故它不需要给“元素定位信息”单元格赋值。</li>
</ul>
<hr>
<h3><a id="_990"></a>窗口处理</h3>
<h4><a id="driver_back__991"></a>driver_back() 关键字</h4>
<blockquote>
<p>浏览器窗口返回上一页</p>
<blockquote>
<p>框架1.1.3版本新增</p>
</blockquote>
</blockquote>
<p><strong>描述</strong><br>
将当前拥有句柄的浏览器窗口的页面栈向前跳转一次，类似浏览器中的“后退”按钮</p>
<blockquote>
<p>页面1 → 页面2 → 页面3  （←为向前，→为向后）</p>
</blockquote>
<p><strong>参数</strong><br>
无参</p>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>driver_back</td>
<td></td>
<td></td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>driver_back</td>
<td></td>
<td></td>
<td></td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>driver_back<span class="token punctuation">(</span><span class="token punctuation">)</span>  <span class="token comment"># 返回上一页</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字主要用于将当前正在活动窗口的页面栈向前跳转，效果等同于点击浏览器的“返回上一页”按钮。</li>
<li>关键字本身没有任何逻辑操作，故它不需要给“元素定位信息”和“操作值”单元格赋值</li>
</ul>
<hr>
<h4><a id="driver_refresh__1023"></a>driver_refresh() 关键字</h4>
<blockquote>
<p>刷新当前正在活动的浏览器窗口</p>
</blockquote>
<p><strong>描述</strong><br>
将当前拥有句柄的浏览器窗口整个刷新，类似浏览器中的“重新加载”按钮</p>
<p><strong>参数</strong><br>
无参</p>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>driver_refresh</td>
<td></td>
<td></td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>driver_refresh</td>
<td></td>
<td></td>
<td></td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>driver_refresh<span class="token punctuation">(</span><span class="token punctuation">)</span>  <span class="token comment"># 刷新</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字主要用于刷新当前正在活动的窗口，效果等同于点击浏览器的重新加载按钮。</li>
<li>关键字本身没有任何逻辑操作，故它不需要给“元素定位信息”和“操作值”单元格赋值</li>
</ul>
<hr>
<h4><a id="driver_close__1053"></a>driver_close() 关键字</h4>
<blockquote>
<p>关闭当前正在活动的浏览器窗口</p>
</blockquote>
<p><strong>描述</strong><br>
将当前拥有句柄的浏览器窗口关闭，类似浏览器中的“X 关闭”按钮</p>
<p><strong>参数</strong><br>
无参</p>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>quit_browser</td>
<td></td>
<td></td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>quit_browser</td>
<td></td>
<td></td>
<td></td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>quit_browser<span class="token punctuation">(</span><span class="token punctuation">)</span>  <span class="token comment"># 窗口关闭</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字主要用于将当前拥有句柄的窗口关闭，效果等同于点击浏览器的关闭按钮。</li>
<li>关键字本身没有任何逻辑操作，故它不需要给“元素定位信息”和“操作值”单元格赋值</li>
</ul>
<hr>
<h4><a id="gethandle__1083"></a>gethandle() 关键字</h4>
<blockquote>
<p>获取当前窗口句柄<br>
特殊：需要同 <code>enterWindow() 关键字</code> 和 <code>outWindow() 关键字</code> 一同使用，单独使用无意义</p>
</blockquote>
<p><strong>描述</strong><br>
获取当前活动窗口的句柄，并存入到缓存中</p>
<p><strong>参数</strong><br>
无参</p>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>进入登录窗口</td>
<td>xxx</td>
<td></td>
<td align="left"></td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>当前窗口句柄获取</td>
<td><font color="blue"><strong>gethandle</strong></font></td>
<td></td>
<td align="left"></td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>点击注册按钮，弹出注册窗口</td>
<td>xxx</td>
<td></td>
<td align="left"></td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>窗口句柄跳转入注册窗口</td>
<td>enterWindow</td>
<td></td>
<td align="left"></td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>输入用户名</td>
<td>xxx</td>
<td></td>
<td align="left"></td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>输入密码</td>
<td>xxx</td>
<td></td>
<td align="left"></td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>点击提交按钮</td>
<td>xxx</td>
<td></td>
<td align="left"></td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>关闭注册窗口，句柄跳出回到登录窗口</td>
<td>outWindow</td>
<td></td>
<td align="left"></td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>gethandle</td>
<td></td>
<td></td>
<td align="left"></td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>gethandle<span class="token punctuation">(</span><span class="token punctuation">)</span>  <span class="token comment"># 当前窗口句柄获取</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>需要同 <code>enterWindow() 关键字</code> 和 <code>outWindow() 关键字</code> 一同使用，单独使用无意义。</li>
</ul>
<hr>
<h4><a id="enterWindow__1120"></a>enterWindow() 关键字</h4>
<blockquote>
<p>窗口句柄跳入<br>
特殊：需要同 <code>gethandle() 关键字</code> 和 <code>outWindow() 关键字</code> 一同使用，单独使用无意义</p>
</blockquote>
<p><strong>描述</strong><br>
找到当前测试环境中的“新窗口”，并将句柄跳转入其中(支持在句柄跳转时控制跳入窗口的大小)，当传入的操作值为<code>True</code>时表示要最大化窗口，值为空或者<code>False</code>时表示保持窗口原样</p>
<p><strong>参数</strong><br>
无参</p>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>进入登录窗口</td>
<td>xxx</td>
<td></td>
<td align="left"></td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>当前窗口句柄获取</td>
<td>gethandle</td>
<td></td>
<td align="left"></td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>点击注册按钮，弹出注册窗口</td>
<td>xxx</td>
<td></td>
<td align="left"></td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>窗口句柄跳转入注册窗口，并将其最大化</td>
<td><font color="blue"><strong>enterWindow</strong></font></td>
<td></td>
<td align="left">True</td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>输入用户名</td>
<td>xxx</td>
<td></td>
<td align="left"></td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>输入密码</td>
<td>xxx</td>
<td></td>
<td align="left"></td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>点击提交按钮</td>
<td>xxx</td>
<td></td>
<td align="left"></td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>关闭注册窗口，句柄跳出回到登录窗口</td>
<td>outWindow</td>
<td></td>
<td align="left"></td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>enterWindow</td>
<td></td>
<td></td>
<td align="left">True / False</td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>enterWindow<span class="token punctuation">(</span><span class="token string">'窗口最大化开关 True / False'</span><span class="token punctuation">)</span>  <span class="token comment"># 窗口句柄跳入</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>需要同 <code>gethandle() 关键字</code> 和 <code>outWindow() 关键字</code> 一同使用，单独使用无意义。</li>
<li>content形参(在用例步骤中为 “操作值” 单元格中书写的值)为布尔型<code>True</code> || <code>False</code>，当值为<code>True</code>时表示要最大化窗口，值为空或者<code>False</code>时表示保持窗口原样。</li>
</ul>
<hr>
<h4><a id="outWindow__1158"></a>outWindow() 关键字</h4>
<blockquote>
<p>窗口句柄跳出<br>
特殊：需要同 <code>gethandle() 关键字</code> 和 <code>enterWindow() 关键字</code> 一同使用，单独使用无意义</p>
</blockquote>
<p><strong>描述</strong><br>
将句柄返回上一级窗口，关闭当前拥有句柄的窗口并将该窗口的句柄从缓存中移除</p>
<p><strong>参数</strong><br>
无参</p>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>进入登录窗口</td>
<td>xxx</td>
<td></td>
<td align="left"></td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>当前窗口句柄获取</td>
<td>gethandle</td>
<td></td>
<td align="left"></td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>点击注册按钮，弹出注册窗口</td>
<td>xxx</td>
<td></td>
<td align="left"></td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>窗口句柄跳转入注册窗口</td>
<td>enterWindow</td>
<td></td>
<td align="left"></td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>输入用户名</td>
<td>xxx</td>
<td></td>
<td align="left"></td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>输入密码</td>
<td>xxx</td>
<td></td>
<td align="left"></td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>点击提交按钮</td>
<td>xxx</td>
<td></td>
<td align="left"></td>
</tr>
<tr>
<td></td>
<td>n</td>
<td>关闭注册窗口，句柄跳出回到登录窗口</td>
<td><font color="blue"><strong>outWindow</strong></font></td>
<td></td>
<td align="left"></td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>outWindow</td>
<td></td>
<td></td>
<td align="left"></td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>outWindow<span class="token punctuation">(</span><span class="token punctuation">)</span>  <span class="token comment"># 窗口句柄跳出</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>需要同 <code>gethandle() 关键字</code> 和 <code>enterWindow() 关键字</code> 一同使用，单独使用无意义。</li>
<li>该关键字在句柄跳出的同时，会将当前窗口的句柄从缓存中移除。</li>
</ul>
<hr>
<h3><a id="_1196"></a>元素操作</h3>
<h4><a id="input_text__1197"></a>input_text() 关键字</h4>
<a id="input_text">
</a><blockquote>
<p>在指定的元素中输入指定内容</p>
</blockquote>
<p><strong>描述</strong><br>
根据传入的元素定位信息找到元素，并在元素中输入指定的内容</p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>定位方式，定位表达式 [, 索引位置][, 父级对象]</td>
<td>要输入的内容</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>input_text</td>
<td>key1/key2</td>
<td>要输入的内容</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>input_text</td>
<td>id/name/…</td>
<td>对应表达式</td>
<td>要输入的内容</td>
</tr>
</tbody>
</table><p><strong>元素节点数据区分 elementData.yaml文件书写示例</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># 区分元素节点数据 - “元素定位信息”elementData.yaml文件书写示例</span>
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span> id <span class="token punctuation">|</span><span class="token punctuation">|</span> ids <span class="token punctuation">|</span><span class="token punctuation">|</span> xpath <span class="token punctuation">|</span><span class="token punctuation">|</span> xpaths …   <span class="token comment"># 框架中支持即可</span>
    <span class="token punctuation">-</span> 对应方式的定位表达式
    <span class="token punctuation">-</span> <span class="token punctuation">[</span> 0<span class="token punctuation">-</span>n <span class="token punctuation">]</span>  <span class="token comment"># index索引，在复数定位时可使用此项(定位方式末尾带有‘s’时为复数定位)；可省略</span>
</code></pre>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>input_text<span class="token punctuation">(</span><span class="token string">'定位方式'</span><span class="token punctuation">,</span><span class="token string">'定位表达式'</span><span class="token punctuation">,</span>content<span class="token operator">=</span><span class="token string">'要输入的内容'</span><span class="token punctuation">[</span><span class="token punctuation">,</span>index<span class="token operator">=</span><span class="token string">'索引值'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token punctuation">,</span>ParentObject<span class="token operator">=</span><span class="token string">'父级元素对象'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 内容输入</span>

<span class="token triple-quoted-string string">'''
def input_text(self, targeting, element, index=None, content=None, ParentObject=None) 注意关键字在定义时的参数顺序 
@ targeting: 定位方式
@ element: 定位表达式
@ index: 索引
@ content: 要输入的内容
@ ParentObject: 父级element对象

注意：根据python的函数传参规则，若要按照顺序传参的方式调用关键字，则需要严格按照关键字在定义时的参数位置顺序进行参数值书写，若不按照顺序传参的方式调用关键字，则需要在调用时标明参数值的形参名称如 ‘targeting=xx’ ‘element=xx’ ‘index=xx’等。
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>input_text<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> <span class="token number">0</span><span class="token punctuation">,</span> <span class="token string">'百度搜索'</span><span class="token punctuation">)</span>  <span class="token comment"># 内容输入</span>
	
<span class="token comment"># 实例二</span>
keyword<span class="token punctuation">.</span>input_text<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token string">'百度搜索'</span><span class="token punctuation">)</span>  <span class="token comment"># 内容输入</span>

<span class="token comment"># 实例三</span>
elementObject <span class="token operator">=</span> keyword<span class="token punctuation">.</span>locator<span class="token punctuation">(</span><span class="token string">'tag_name'</span><span class="token punctuation">,</span> <span class="token string">'body'</span><span class="token punctuation">)</span>  <span class="token comment"># 父级元素定位</span>
keyword<span class="token punctuation">.</span>input_text<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token string">'百度搜索'</span><span class="token punctuation">,</span> ParentObject<span class="token operator">=</span>elementObject<span class="token punctuation">)</span>  <span class="token comment"># 内容输入</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字主要用于对当前活动页面中的指定元素输入指定的内容，注意只对可进行输入操作的元素有效。</li>
<li>如果想要在输入时清空对应元素的原始内容，则应将要输入的内容用中括号“[]”包裹，例如[‘xxx’] 、[10]；注意如果内容为字符串或者汉字则必须在中括号中用引号引起来，否则会出现错误。</li>
<li>如果你只是想清空值而不输入值，则可以直接传入“[]”即可。</li>
<li>至于关键字中的“父级对象”形参(后代元素定位)，主要在脚本中调用关键字时使用，用例步骤中不使用。</li>
</ul>
<hr>
<h4><a id="click_btn__1264"></a>click_btn() 关键字</h4>
<a id="click_btn">
</a><blockquote>
<p>对指定的元素进行点击操作</p>
</blockquote>
<p><strong>描述</strong><br>
根根据传入的元素定位信息找到元素，并对该元素进行点击操作(鼠标左键单击)</p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>定位方式，定位表达式 [, 索引位置][, 父级对象]</td>
<td>无参</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>click_btn</td>
<td>key1/key2</td>
<td></td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>click_btn</td>
<td>id/name/…</td>
<td>对应表达式</td>
<td></td>
</tr>
</tbody>
</table><p><strong>元素节点数据区分 elementData.yaml文件书写示例</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># 区分元素节点数据 - “元素定位信息”elementData.yaml文件书写示例</span>
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span> id <span class="token punctuation">|</span><span class="token punctuation">|</span> ids <span class="token punctuation">|</span><span class="token punctuation">|</span> xpath <span class="token punctuation">|</span><span class="token punctuation">|</span> xpaths …   <span class="token comment"># 框架中支持即可</span>
    <span class="token punctuation">-</span> 对应方式的定位表达式
    <span class="token punctuation">-</span> <span class="token punctuation">[</span> 0<span class="token punctuation">-</span>n <span class="token punctuation">]</span>  <span class="token comment"># index索引，在复数定位时可使用此项(定位方式末尾带有‘s’时为复数定位)；可省略</span>
</code></pre>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>click_btn<span class="token punctuation">(</span><span class="token string">'定位方式'</span><span class="token punctuation">,</span><span class="token string">'定位表达式'</span><span class="token punctuation">[</span><span class="token punctuation">,</span>index<span class="token operator">=</span><span class="token string">'索引值'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token punctuation">,</span>ParentObject<span class="token operator">=</span><span class="token string">'父级元素对象'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 元素点击</span>

<span class="token triple-quoted-string string">'''
def click_btn(self, targeting, element, index=None, ParentObject=None) 注意关键字在定义时的参数顺序
@ targeting: 定位方式
@ element: 定位表达式
@ index: 索引
@ ParentObject: 父级element对象

注意：根据python的函数传参规则，若要按照顺序传参的方式调用关键字，则需要严格按照关键字在定义时的参数位置顺序进行参数值书写，若不按照顺序传参的方式调用关键字，则需要在调用时标明参数值的形参名称如 ‘targeting=xx’ ‘element=xx’ ‘index=xx’等等。
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>click_btn<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">)</span>  <span class="token comment"># 元素点击</span>

<span class="token comment"># 实例二</span>
keyword<span class="token punctuation">.</span>click_btn<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">)</span>  <span class="token comment"># 元素点击</span>

<span class="token comment"># 实例三</span>
elementObject <span class="token operator">=</span> keyword<span class="token punctuation">.</span>locator<span class="token punctuation">(</span><span class="token string">'tag_name'</span><span class="token punctuation">,</span> <span class="token string">'body'</span><span class="token punctuation">)</span>  <span class="token comment"># 父级元素定位</span>
keyword<span class="token punctuation">.</span>click_btn<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">,</span> ParentObject<span class="token operator">=</span>elementObject<span class="token punctuation">)</span>  <span class="token comment"># 元素点击</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字用于对指定元素进行点击操作(模拟鼠标左键点击)；并非只有按钮元素才可使用该方法，对页面中的任何元素均生效(点击效果需要视实际元素类型而定)。</li>
<li>至于关键字中的“父级对象”形参(后代元素定位)，主要在脚本中调用关键字时使用，用例步骤中不使用。</li>
</ul>
<hr>
<h4><a id="js_control__1328"></a>js_control() 关键字</h4>
<blockquote>
<p>使用javaScript指令方式对指定元素进行操作（输入、点击等等）</p>
</blockquote>
<p><strong>描述</strong><br>
使用指定的 “javaScript定位操作表达式” 对目标元素进行操作</p>
<p><strong>参数</strong><br>
(特殊，见关键字注意事项)</p>
<p><strong>用例步骤使用示例 （特殊）</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>js_control</td>
<td>key1/key2</td>
<td>要输入的内容  # 操作方法为‘value’时书写</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th>操作</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>js_control</td>
<td>document.getElementById</td>
<td>对应定位值</td>
<td>操作方法</td>
<td>要输入的内容  # 操作方法为‘value’时书写</td>
</tr>
</tbody>
</table><p><strong>元素节点数据区分 elementData.yaml文件书写示例 （特殊）</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># 区分元素节点数据 - “元素定位信息”elementData.yaml文件书写示例</span>
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span> document.getElementById <span class="token punctuation">|</span><span class="token punctuation">|</span> document.getElementsByClassName <span class="token punctuation">|</span><span class="token punctuation">|</span> document.querySelectorAll  <span class="token comment"># 此处为列举，任何合法的JS定位方式均适用</span>
    <span class="token punctuation">-</span> 正常合法的定位表达式
    <span class="token punctuation">-</span> value <span class="token punctuation">|</span><span class="token punctuation">|</span> click()  <span class="token comment"># 操作方式此处为列举，任何合法的JS操作方式均适用</span>
    <span class="token punctuation">-</span> <span class="token punctuation">[</span> 0<span class="token punctuation">-</span>n <span class="token punctuation">]</span>  <span class="token comment"># index索引，非复数定位时不支持使用此项；可省略</span>
</code></pre>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>js_control<span class="token punctuation">(</span><span class="token string">'JS定位方式'</span><span class="token punctuation">,</span><span class="token string">'JS定位表达式'</span><span class="token punctuation">,</span><span class="token string">'JS操作方式'</span><span class="token punctuation">[</span><span class="token punctuation">,</span>index<span class="token operator">=</span><span class="token string">'索引值'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token punctuation">,</span>content<span class="token operator">=</span><span class="token string">'要输入的值'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 元素操作</span>

<span class="token triple-quoted-string string">'''
def js_control(self, targeting, element, behavior, index=None, content=None) 注意关键字在定义时的参数顺序
@ targeting: javaScript定位方式
@ element: javaScript定位表达式
@ behavior: javaScript操作方式
@ index: 索引
@ content: 要输入的值

注意：根据python的函数传参规则，若要按照顺序传参的方式调用关键字，则需要严格按照关键字在定义时的参数位置顺序进行参数值书写，若不按照顺序传参的方式调用关键字，则需要在调用时标明参数值的形参名称如 ‘targeting=xx’ ‘element=xx’ ‘index=xx’等等。
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>js_control<span class="token punctuation">(</span><span class="token string">'document.getElementById'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> behavior<span class="token operator">=</span><span class="token string">'click()'</span><span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">)</span>  <span class="token comment"># 元素操作 - 点击</span>

<span class="token comment"># 实例二</span>
keyword<span class="token punctuation">.</span>js_control<span class="token punctuation">(</span><span class="token string">'document.getElementById'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> behavior<span class="token operator">=</span><span class="token string">'value'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token string">"百度搜索"</span><span class="token punctuation">)</span>  <span class="token comment"># 元素操作 - 内容输入</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字主要应用在“input_text”和“click_btn”关键字无法有效操作元素的场景下，传递的元素定位数据与其它关键字有较大的差别，注意传值限制。</li>
<li>关键字的定位方式有格式限定例如 <code>document.getElementById 对应ID定位</code>、<code>document.querySelectorAll 对应CSS定位</code>、<code>document.getElementsByClassName 对应ClassName定位</code>、<code>document.getElementsByName 对应Name定位</code>，此处为列举任何合法的javaScript定位方式均适用。</li>
<li>关键字的操作方法格式限定例如 <code>click() 对应点击事件</code>、<code>value 对应输入操作</code>，此处为列举任何合法的javaScript操作方式均适用。</li>
<li>由于特殊的定位方式，关键字“是否复数定位”的区别在定位方式的中 <code>.getElement</code> 和 <code>.getElements</code>上体现。</li>
<li>关键字content形参(在用例步骤中为 “操作值” 单元格中书写的值)需要与<code>value</code> 操作方法同时使用，当操作方法为<code>click()</code>时该值不生效为空即可。</li>
</ul>
<hr>
<h4><a id="alert_operation__1388"></a>alert_operation() 关键字</h4>
<blockquote>
<p>对alert提示弹框进行操作</p>
</blockquote>
<p><strong>描述</strong><br>
识别当前页面中的<code>alert</code>、<code>confirm</code>和 <code>prompt</code>弹框，并对其进行指定的操作</p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>无参</td>
<td>string / boole / list</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<blockquote>
<p>string / boole / list : 代表参数类型，详细的说明见<strong>参数说明</strong></p>
</blockquote>
<p><strong>参数说明</strong></p>
<ul>
<li>操作参数支持接收三种类型的参数值，关键字会根据参数值的类型进行相应的处理
<ul>
<li>string: 代表在 <code>prompt</code>弹框的输入框中输入的文本</li>
<li>boole: 代表点击 <code>alert</code>、<code>confirm</code>和 <code>prompt</code>弹框的那个操作按钮（True确定、False取消）</li>
<li>list: 上面两种类型数据的整合，[string, boole]; 代表对<code>prompt</code>弹框进行输入，并点击弹框的指定操作按钮</li>
</ul>
</li>
</ul>
<blockquote>
<p>关键字会自动识别当前弹框的类型，不需要特殊指明；另外参数类型的选择并不是随意的，你需要根据实际的页面场景来决定，不恰当的参数会导致关键字执行出错。例如当弹窗类型为<code>alert</code>或者<code>confirm</code>时，你只能选择“boole类型”，若选择“list类型”和“string类型”关键字就会报错。</p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>alert_operation</td>
<td></td>
<td>string / boole / list</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>alert_operation</td>
<td></td>
<td></td>
<td>string / boole / list</td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>alert_operation<span class="token punctuation">(</span>content<span class="token operator">=</span><span class="token string">"操作数据 string / boole / list"</span><span class="token punctuation">)</span>  <span class="token comment"># alert弹框处理</span>

<span class="token triple-quoted-string string">'''
def alert_operation(self, content=None)
@ content: 操作数据
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>alert_operation<span class="token punctuation">(</span><span class="token boolean">False</span><span class="token punctuation">)</span>  <span class="token comment"># 处理窗口的alert、confirm、prompt弹框，点击弹框【取消】按钮</span>

<span class="token comment"># 实例二</span>
keyword<span class="token punctuation">.</span>alert_operation<span class="token punctuation">(</span><span class="token boolean">True</span><span class="token punctuation">)</span>  <span class="token comment"># 处理窗口的alert、confirm、prompt弹框，点击弹框【确定】按钮</span>

<span class="token comment"># 实例三</span>
keyword<span class="token punctuation">.</span>alert_operation<span class="token punctuation">(</span><span class="token string">'文本内容'</span><span class="token punctuation">)</span>  <span class="token comment"># 处理窗口的prompt弹框，在输入框中输入内容后，点击弹框【取消】按钮</span>

<span class="token comment"># 实例四</span>
keyword<span class="token punctuation">.</span>alert_operation<span class="token punctuation">(</span><span class="token punctuation">[</span><span class="token string">'文本内容'</span><span class="token punctuation">,</span><span class="token boolean">True</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 处理窗口的prompt弹框，在输入框中输入内容后，点击弹框【确定】按钮</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字的弹框操作按钮类型默认为<code>Fasel取消</code>，即若不传入，则在处理弹框时将默认点击弹框的【取消】按钮。</li>
<li>参数值为string类型、list类型时，弹框类型必须为<code>prompt</code>，否则会出现异常报错。</li>
<li>在参数值为list类型时，列表子项必须由 string、boole两项组成，缺一不可；另外两项没有顺序限制，<code>[string, boole]</code> 和 <code>[boole, string]</code> 均可。</li>
<li>在处理 <code>prompt</code>弹框时建议参数类型为list类型，若单独传入“boole 点击操作按钮”或者“string 输入框文本输入”均无实际意义。</li>
</ul>
<hr>
<h4><a id="selector_operation__1449"></a>selector_operation() 关键字</h4>
<a id="selector_operation">
</a><blockquote>
<p>对<code>&lt;select&gt;&lt;/select&gt;  下拉列表框</code>进行列表子项选择</p>
</blockquote>
<p><strong>描述</strong><br>
根据元素定位数据找到指定的<code>&lt;select&gt;&lt;/select&gt; 下拉列表框</code>，并对其中的指定列表子项进行选择；关键字可以根据列表子项的 “value属性值”、“index索引值 ”和“text文本值”对其进行定位选择</p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>定位方式，定位表达式 [, 索引位置][, 父级对象]</td>
<td>[‘子项value值’] / [‘子项index值’] / [‘子项text文本值’]</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>selector_operation</td>
<td>key1/key2</td>
<td align="left">[‘value属性值’] / [‘index索引值’ / [‘text文本值’]</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>selector_operation</td>
<td>id/name/…</td>
<td>对应表达式</td>
<td align="left">[‘value属性值’] / [‘index索引值’] / [‘text文本值’]</td>
</tr>
</tbody>
</table><p><strong>元素节点数据区分 elementData.yaml文件书写示例</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># 区分元素节点数据 - “元素定位信息”elementData.yaml文件书写示例</span>
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span> id <span class="token punctuation">|</span><span class="token punctuation">|</span> ids <span class="token punctuation">|</span><span class="token punctuation">|</span> xpath <span class="token punctuation">|</span><span class="token punctuation">|</span> xpaths …   <span class="token comment"># 框架中支持即可</span>
    <span class="token punctuation">-</span> 对应方式的定位表达式
    <span class="token punctuation">-</span> <span class="token punctuation">[</span> 0<span class="token punctuation">-</span>n <span class="token punctuation">]</span>  <span class="token comment"># index索引，在复数定位时可使用此项(定位方式末尾带有‘s’时为复数定位)；可省略</span>
</code></pre>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>selector_operation<span class="token punctuation">(</span><span class="token string">'定位方式'</span><span class="token punctuation">,</span><span class="token string">'定位表达式'</span><span class="token punctuation">,</span>content<span class="token operator">=</span><span class="token string">'要选择的列表项的标识'</span><span class="token punctuation">[</span><span class="token punctuation">,</span>index<span class="token operator">=</span><span class="token string">'索引值'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token punctuation">,</span>ParentObject<span class="token operator">=</span><span class="token string">'父级元素对象'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 下拉列表项选择</span>

<span class="token triple-quoted-string string">'''
def selector_operation(self, targeting, element, index=None, ParentObject=None, content=None) 注意关键字在定义时的参数顺序
@ targeting: 定位方式
@ element: 定位表达式
@ index: 索引
@ ParentObject: 父级element对象
@ content: 列表项标识值

注意：根据python的函数传参规则，若要按照顺序传参的方式调用关键字，则需要严格按照关键字在定义时的参数位置顺序进行参数值书写，若不按照顺序传参的方式调用关键字，则需要在调用时标明参数值的形参名称如 ‘targeting=xx’ ‘element=xx’ ‘index=xx’等等。
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>selector_operation<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> <span class="token number">0</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">[</span><span class="token string">'否'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 列表项选择，此处的‘否’为要选择列表项的text文本值</span>

<span class="token comment"># 实例二</span>
keyword<span class="token punctuation">.</span>selector_operation<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">[</span><span class="token string">'f'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 列表项选择，此处的‘f’为要选择列表项的value属性值</span>

<span class="token comment"># 实例三</span>
elementObject <span class="token operator">=</span> keyword<span class="token punctuation">.</span>locator<span class="token punctuation">(</span><span class="token string">'tag_name'</span><span class="token punctuation">,</span> <span class="token string">'body'</span><span class="token punctuation">)</span>  <span class="token comment"># 父级元素定位</span>
keyword<span class="token punctuation">.</span>selector_operation<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">[</span><span class="token number">1</span><span class="token punctuation">]</span><span class="token punctuation">,</span> ParentObject<span class="token operator">=</span>elementObject<span class="token punctuation">)</span>  <span class="token comment"># 列表项选择，此处的‘1’为要选择列表项的index索引值</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>content形参(在用例步骤中为 “操作值” 单元格中书写的值)应为list类型，支持接收“value属性值”、“index索引值”和“text文本值”中的任意一个。</li>
<li>关键字会根据实际的情况对传入值的类型进行判断，不需要特殊声明。</li>
<li>content形参(在用例步骤中为 ‘操作值’ 单元格中书写的值)接收的列表中仅允许存在一个值，若存在多个值则以列表中0号索引的值为准。</li>
<li>至于关键字中的“父级对象”形参(后代元素定位)，主要在脚本中调用关键字时使用，用例步骤中不使用。</li>
</ul>
<hr>
<h4><a id="radioCheck_operation__1516"></a>radioCheck_operation() 关键字</h4>
<a id="radioCheck_operation">
</a><blockquote>
<p>对<code>单/复选按钮</code>进行选中操作</p>
</blockquote>
<p><strong>描述</strong><br>
根据元素定位数据找到指定的<code>单/复选按钮</code>，并根据其当前的“选中状态”判断是否对其进行操作。</p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>定位方式，定位表达式 [, 索引位置][, 父级对象]</td>
<td>True/False</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>radioCheck_operation</td>
<td>key1/key2</td>
<td align="left">True/False</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>radioCheck_operation</td>
<td>id/name/…</td>
<td>对应表达式</td>
<td align="left">True/False</td>
</tr>
</tbody>
</table><p><strong>元素节点数据区分 elementData.yaml文件书写示例</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># 区分元素节点数据 - “元素定位信息”elementData.yaml文件书写示例</span>
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span> id <span class="token punctuation">|</span><span class="token punctuation">|</span> ids <span class="token punctuation">|</span><span class="token punctuation">|</span> xpath <span class="token punctuation">|</span><span class="token punctuation">|</span> xpaths …   <span class="token comment"># 框架中支持即可</span>
    <span class="token punctuation">-</span> 对应方式的定位表达式
    <span class="token punctuation">-</span> <span class="token punctuation">[</span> 0<span class="token punctuation">-</span>n <span class="token punctuation">]</span>  <span class="token comment"># index索引，在复数定位时可使用此项(定位方式末尾带有‘s’时为复数定位)；可省略</span>
</code></pre>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>radioCheck_operation<span class="token punctuation">(</span><span class="token string">'定位方式'</span><span class="token punctuation">,</span><span class="token string">'定位表达式'</span><span class="token punctuation">[</span><span class="token punctuation">,</span>index<span class="token operator">=</span><span class="token string">'索引值'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token punctuation">,</span>ParentObject<span class="token operator">=</span><span class="token string">'父级元素对象'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token punctuation">,</span>content<span class="token operator">=</span><span class="token string">'True/False'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 单/复选按钮选择</span>

<span class="token triple-quoted-string string">'''
def radioCheck_operation(self, targeting, element, index=None, ParentObject=None, content=True) 注意关键字在定义时的参数顺序
@ targeting: 定位方式
@ element: 定位表达式
@ index: 索引
@ ParentObject: 父级element对象
@ content: 选中类型

注意：根据python的函数传参规则，若要按照顺序传参的方式调用关键字，则需要严格按照关键字在定义时的参数位置顺序进行参数值书写，若不按照顺序传参的方式调用关键字，则需要在调用时标明参数值的形参名称如 ‘targeting=xx’ ‘element=xx’ ‘index=xx’等等。
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>radioCheck_operation<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> <span class="token number">0</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token boolean">True</span><span class="token punctuation">)</span>  <span class="token comment"># 将“单/复选”按钮选中</span>

<span class="token comment"># 实例二</span>
keyword<span class="token punctuation">.</span>radioCheck_operation<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token boolean">False</span><span class="token punctuation">)</span>  <span class="token comment"># 取消“单/复选”按钮的选中</span>

<span class="token comment"># 实例三</span>
elementObject <span class="token operator">=</span> keyword<span class="token punctuation">.</span>locator<span class="token punctuation">(</span><span class="token string">'tag_name'</span><span class="token punctuation">,</span> <span class="token string">'body'</span><span class="token punctuation">)</span>  <span class="token comment"># 父级元素定位</span>
keyword<span class="token punctuation">.</span>radioCheck_operation<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token boolean">False</span><span class="token punctuation">,</span> ParentObject<span class="token operator">=</span>elementObject<span class="token punctuation">)</span>  <span class="token comment"># 取消“单/复选”按钮的选中</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>content形参(在用例步骤中为 “操作值” 单元格中书写的值)代表元素选中操作标识；<code>True [默认]</code> 对元素进行选中，<code>False</code>指定元素不选中。</li>
<li>若content形参(在用例步骤中为 “操作值” 单元格中书写的值)为空，或者书写了除 <code>True</code>、<code>False</code>之外的值，则默认对元素进行选中操作。</li>
<li>若元素的状态(选中状态)与元素选中标识(content)不一致则对元素进行操作，若一致则忽略跳过。</li>
</ul>
<hr>
<h4><a id="drag_scrollBar__1582"></a>drag_scrollBar() 关键字</h4>
<a id="drag_scrollBar">
</a><blockquote>
<p>将当前活动窗口中的滚动条拖动到指定元素所在的位置</p>
</blockquote>
<p><strong>描述</strong><br>
根据元素定位数据找到对应的元素，并将窗口中的滚动条拖动到元素所在的位置，以解决在页面内容溢出时的元素遮挡问题</p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>定位方式，定位表达式 [, 索引位置][, 父级对象]</td>
<td>top / bottom</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>drag_scrollBar</td>
<td>key1/key2</td>
<td align="left">top</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>drag_scrollBar</td>
<td>id/name/…</td>
<td>对应表达式</td>
<td align="left">bottom</td>
</tr>
</tbody>
</table><p><strong>元素节点数据区分 elementData.yaml文件书写示例</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># 区分元素节点数据 - “元素定位信息”elementData.yaml文件书写示例</span>
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span> id <span class="token punctuation">|</span><span class="token punctuation">|</span> ids <span class="token punctuation">|</span><span class="token punctuation">|</span> xpath <span class="token punctuation">|</span><span class="token punctuation">|</span> xpaths …   <span class="token comment"># 框架中支持即可</span>
    <span class="token punctuation">-</span> 对应方式的定位表达式
    <span class="token punctuation">-</span> <span class="token punctuation">[</span> 0<span class="token punctuation">-</span>n <span class="token punctuation">]</span>  <span class="token comment"># index索引，在复数定位时可使用此项；可省略</span>
</code></pre>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>drag_scrollBar<span class="token punctuation">(</span><span class="token string">'定位方式'</span><span class="token punctuation">,</span><span class="token string">'定位表达式'</span><span class="token punctuation">[</span><span class="token punctuation">,</span>index<span class="token operator">=</span><span class="token string">'索引值'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token punctuation">,</span>content<span class="token operator">=</span><span class="token string">'对齐参照'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token punctuation">,</span>ParentObject<span class="token operator">=</span><span class="token string">'父级元素对象'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 窗口滚动条拖动</span>

<span class="token triple-quoted-string string">'''
def drag_scrollBar(self, targeting, element, index=None, content=None, ParentObject=None) 注意关键字在定义时的参数顺序
@ targeting: 定位方式
@ element: 定位表达式
@ index: 索引
@ content: 对齐参照
@ ParentObject: 父级element对象

注意：根据python的函数传参规则，若要按照顺序传参的方式调用关键字，则需要严格按照关键字在定义时的参数位置顺序进行参数值书写，若不按照顺序传参的方式调用关键字，则需要在调用时标明参数值的形参名称如 ‘targeting=xx’ ‘element=xx’ ‘index=xx’等等。
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>drag_scrollBar<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">)</span>  <span class="token comment"># 将窗口滚动条拖动至目标元素与窗口顶部对齐的位置</span>

<span class="token comment"># 实例二</span>
keyword<span class="token punctuation">.</span>drag_scrollBar<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> <span class="token number">0</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token string">'bottom'</span><span class="token punctuation">)</span>  <span class="token comment"># 将窗口滚动条拖动至目标元素与窗口底部对齐的位置</span>

<span class="token comment"># 实例三</span>
elementObject <span class="token operator">=</span> keyword<span class="token punctuation">.</span>locator<span class="token punctuation">(</span><span class="token string">'tag_name'</span><span class="token punctuation">,</span> <span class="token string">'body'</span><span class="token punctuation">)</span>  <span class="token comment"># 父级元素定位</span>
keyword<span class="token punctuation">.</span>drag_scrollBar<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token string">'top'</span><span class="token punctuation">,</span> ParentObject<span class="token operator">=</span>elementObject<span class="token punctuation">)</span>  <span class="token comment"># 将窗口滚动条拖动至目标元素与窗口顶部对齐的位置</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>content形参(在用例步骤中为 “操作值” 单元格中书写的值)代表滚动条拖动结束后，目标元素与窗口对齐的位置，<code>top [默认]</code> 代表与窗口顶部对齐，<code>bottom</code> 代表与窗口底部对齐。</li>
<li>若content形参(在用例步骤中为 “操作值” 单元格中书写的值)为空，则默认代表滚动条拖动结束后，目标元素与窗口的顶部对齐。</li>
<li>关键字会根据实际情况对页面的“X轴”和“Y轴”进行拖动，不需要特殊标明。</li>
<li>注意关键字所定位的元素并不是要被拖动的元素，而是窗口滚动条拖动时的位置参照元素，通常是由于页面过长或者过宽导致无法显示的元素。</li>
<li>至于关键字中的“父级对象”形参(后代元素定位)，主要在脚本中调用关键字时使用，用例步骤中不使用。</li>
</ul>
<hr>
<h3><a id="_1650"></a>数据断言</h3>
<h4><a id="title_assert__1651"></a>title_assert() 关键字</h4>
<blockquote>
<p>对页面的title标题值做断言判断</p>
</blockquote>
<p><strong>描述</strong><br>
取出页面的title标题值，将其与 ‘预期结果’ 做断言判断，若两值一致则返回 <code>True</code> 反之返回 <code>False</code></p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>无参</td>
<td>预期title标题值</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>title_assert</td>
<td></td>
<td align="left">预期title标题值</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>title_assert</td>
<td></td>
<td></td>
<td align="left">预期title标题值</td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
<span class="token keyword">if</span> keyword<span class="token punctuation">.</span>title_assert<span class="token punctuation">(</span><span class="token string">'百度一下'</span><span class="token punctuation">)</span><span class="token punctuation">:</span>  <span class="token comment"># 页面title值断言</span>
	<span class="token keyword">print</span><span class="token punctuation">(</span><span class="token boolean">True</span><span class="token punctuation">)</span>
<span class="token keyword">else</span><span class="token punctuation">:</span>
	<span class="token keyword">print</span><span class="token punctuation">(</span><span class="token boolean">False</span><span class="token punctuation">)</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>如果需要对预期结果进行值包含比较，则应将要比较的预期结果用中括号“[]”包裹，例如[‘xxx’] 、[10]；注意如果预期结果为字符串或者汉字则必须在中括号中用引号引起来，否则会出现错误。</li>
</ul>
<hr>
<h4><a id="alert_assert__1686"></a>alert_assert() 关键字</h4>
<blockquote>
<p>对页面的alert弹框提示文本进行断言</p>
</blockquote>
<p><strong>描述</strong><br>
识别当前页面中的<code>alert</code>弹框，并对其中的提示文本进行断言</p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>无参</td>
<td>预期提示文本值 / [‘预期提示文本值’]</td>
</tr>
</tbody>
</table><p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>alert_assert</td>
<td></td>
<td align="left">预期title标题值 / [‘预期提示文本值’]</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>alert_assert</td>
<td></td>
<td></td>
<td align="left">预期title标题值 / [‘预期提示文本值’]</td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
<span class="token keyword">if</span> keyword<span class="token punctuation">.</span>alert_assert<span class="token punctuation">(</span><span class="token string">'确定此操作吗？'</span><span class="token punctuation">)</span><span class="token punctuation">:</span>  <span class="token comment"># alert弹框提示文本断言</span>
	<span class="token keyword">print</span><span class="token punctuation">(</span><span class="token boolean">True</span><span class="token punctuation">)</span>
<span class="token keyword">else</span><span class="token punctuation">:</span>
	<span class="token keyword">print</span><span class="token punctuation">(</span><span class="token boolean">False</span><span class="token punctuation">)</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>如果需要对预期结果进行值包含比较，则应将要比较的预期结果用中括号“[]”包裹，例如[‘xxx’] 、[10]；注意如果预期结果为字符串或者汉字则必须在中括号中用引号引起来，否则会出现错误。</li>
</ul>
<hr>
<h4><a id="selector_assert__1720"></a>selector_assert() 关键字</h4>
<a id="selector_assert">
</a><blockquote>
<p>对<code>&lt;select&gt;&lt;/select&gt; 下拉列表框</code>中的列表子项进行断言检查</p>
</blockquote>
<p><strong>描述</strong><br>
用于对<code>&lt;select&gt;&lt;/select&gt; 下拉列表框</code>中的列表子项进行断言检查，关键字可根据“操作参数”的不同进行两种不同的断言判断，分别为“<code>验证预期列表项是否存在</code>”和“<code>当前选中的列表项是否为预期列表项</code>”，不管是那种断言判断成立则返回<code>True</code>不成立则返回<code>False</code></p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>定位方式, 定位表达式 [, 索引位置][, 父级对象]</td>
<td>预期列表项text文本值 / (‘预期列表项text文本值’,)</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em><br>
(xxx,) 代表python <code>tuple</code>元组数据类型</p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>selector_assert</td>
<td>key1/key2</td>
<td align="left">预期子项text文本值 // (’ 预期子项text文本值’,)</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>selector_assert</td>
<td>id/css…</td>
<td>对应表达式</td>
<td align="left">预期子项text文本值 // (’ 预期子项text文本值’,)</td>
</tr>
</tbody>
</table><p><strong>元素节点数据区分 elementData.yaml文件书写示例</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># 区分元素节点数据 - “元素定位信息”elementData.yaml文件书写示例</span>
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span> id <span class="token punctuation">|</span><span class="token punctuation">|</span> ids <span class="token punctuation">|</span><span class="token punctuation">|</span> xpath <span class="token punctuation">|</span><span class="token punctuation">|</span> xpaths …   <span class="token comment"># 框架中支持即可</span>
    <span class="token punctuation">-</span> 对应方式的定位表达式
    <span class="token punctuation">-</span> <span class="token punctuation">[</span> 0<span class="token punctuation">-</span>n <span class="token punctuation">]</span>  <span class="token comment"># index索引，在复数定位时可使用此项；可省略</span>
</code></pre>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>selector_assert<span class="token punctuation">(</span><span class="token string">'定位方式'</span><span class="token punctuation">,</span><span class="token string">'定位表达式'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token string">'预期列表项'</span><span class="token punctuation">[</span><span class="token punctuation">,</span>index<span class="token operator">=</span><span class="token string">'索引值'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token punctuation">,</span>ParentObject<span class="token operator">=</span><span class="token string">'父级元素对象'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># select下拉列表框，列表项断言</span>

<span class="token triple-quoted-string string">'''
def selector_assert(self, targeting, element, index=None, content=None, ParentObject=None) 注意关键字在定义时的参数顺序
@ targeting: 定位方式
@ element: 定位表达式
@ index: 索引
@ content: 代表预期列表项
@ ParentObject: 父级element对象

注意：根据python的函数传参规则，若要按照顺序传参的方式调用关键字，则需要严格按照关键字在定义时的参数位置顺序进行参数值书写，若不按照顺序传参的方式调用关键字，则需要在调用时标明参数值的形参名称如 ‘targeting=xx’ ‘element=xx’ ‘index=xx’等等。
'''</span>
实例一：
keyword<span class="token punctuation">.</span>selector_assert<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token string">'预期列表项text文本值'</span><span class="token punctuation">)</span>  <span class="token comment"># 判断当前选中的列表项是否为预期列表项</span>

实例二：
keyword<span class="token punctuation">.</span>selector_assert<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">(</span><span class="token string">'预期列表项text文本值'</span><span class="token punctuation">,</span><span class="token punctuation">)</span><span class="token punctuation">)</span>  <span class="token comment"># 判断预期列表项是否存在</span>

实例三：
elementObject <span class="token operator">=</span> keyword<span class="token punctuation">.</span>locator<span class="token punctuation">(</span><span class="token string">'tag_name'</span><span class="token punctuation">,</span> <span class="token string">'body'</span><span class="token punctuation">)</span>  <span class="token comment"># 父级元素定位</span>
keyword<span class="token punctuation">.</span>selector_assert<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">(</span><span class="token string">'预期列表项text文本值'</span><span class="token punctuation">,</span><span class="token punctuation">)</span><span class="token punctuation">,</span> ParentObject<span class="token operator">=</span>elementObject <span class="token punctuation">)</span>  <span class="token comment"># 判断预期列表项是否存在</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字中参与比较断言的是<code>&lt;select&gt;&lt;/select&gt;下拉列表框</code>中列表子项的“text文本值”，不支持对子项的“index索引”和“value属性”做比较断言。</li>
<li>content形参(在用例步骤中为 “操作值” 单元格中书写的值)支持两种值书写方式分别为“<code>'预期子项text文本值'</code> ”和  “<code>('预期子项text文本值',)</code>”。
<ul>
<li><code>'预期子项text文本值'</code>：代表验证当前选中的列表项是否为预期列表项。(验证下拉列表框当前选中的列表项的“text文本值”是否与预期的“列表项text文本值”一致)</li>
<li><code>('预期子项text文本值',)</code>：代表验证预期列表项是否存在于<code>&lt;select&gt;&lt;/select&gt;下拉列表框</code>子项中。(验证下拉列表框中是否包含有和预期“列表项”text文本值一致的列表项)</li>
</ul>
</li>
<li>如果想要进行值“包含”比较，则需要将要比较的预期值包裹在中括号[]中，例如 [‘预期值’]   ([‘预期值’],)。</li>
<li>在进行“<code>验证预期列表项是否存在</code>”断言时，要注意参数中的“ ,逗号”为python语法不可省略；(‘预期值’,)   ([‘预期值’],)。</li>
<li>关键字中的“父级对象”形参(后代元素定位)，主要在脚本中调用关键字时使用，用例步骤中不使用。</li>
</ul>
<hr>
<h4><a id="selfText_assert__1791"></a>selfText_assert() 关键字</h4>
<a id="selfText_assert">
</a><blockquote>
<p>元素text文本值比较断言</p>
</blockquote>
<p><strong>描述</strong><br>
对指定元素的text文本值进行比较断言，若预期文本值与实际文本值一致则返回<code>True</code>反之则返回<code>False</code></p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>定位方式, 定位表达式 [, 索引位置]</td>
<td>预期文本值 / [‘预期文本值’] / “”</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>selfText_assert</td>
<td>key1/key2</td>
<td align="left">预期文本值 / [‘预期文本值’] / “”</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>selfText_assert</td>
<td>id/dis/xpaths…</td>
<td>对应表达式</td>
<td align="left">预期文本值 / [‘预期文本值’] / “”</td>
</tr>
</tbody>
</table><p><strong>元素节点数据区分 elementData.yaml文件书写示例</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># 区分元素节点数据 - “元素定位信息”elementData.yaml文件书写示例</span>
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span>  id <span class="token punctuation">|</span><span class="token punctuation">|</span> xpath <span class="token punctuation">|</span><span class="token punctuation">|</span> css_selectors …   <span class="token comment"># 框架中支持即可</span>
    <span class="token punctuation">-</span> 对应方式的定位表达式
    <span class="token punctuation">-</span> <span class="token punctuation">[</span> 0<span class="token punctuation">-</span>n <span class="token punctuation">]</span>  <span class="token comment"># index索引，在复数定位时可使用此项(定位方式末尾带有‘s’时为复数定位)；可省略</span>
</code></pre>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>selfText_assert<span class="token punctuation">(</span><span class="token string">'定位方式'</span><span class="token punctuation">,</span><span class="token string">'定位表达式'</span><span class="token punctuation">,</span>content<span class="token operator">=</span><span class="token string">'预期文本值'</span><span class="token punctuation">[</span><span class="token punctuation">,</span>index<span class="token operator">=</span><span class="token string">'索引值'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 元素text文本值断言</span>

<span class="token triple-quoted-string string">'''
def selfText_assert(self, targeting, element, index=None, content=None) 注意关键字在定义时的参数顺序
@ targeting: 定位方式
@ element: 定位表达式
@ index: 索引
@ content: 预期文本值

注意：根据python的函数传参规则，若要按照顺序传参的方式调用关键字，则需要严格按照关键字在定义时的参数位置顺序进行参数值书写，若不按照顺序传参的方式调用关键字，则需要在调用时标明参数值的形参名称如 ‘targeting=xx’ ‘element=xx’ ‘index=xx’等等。
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>selfText_assert<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token string">"百度一下"</span><span class="token punctuation">)</span>  <span class="token comment"># 元素文本值断言</span>

<span class="token comment"># 实例二</span>
keyword<span class="token punctuation">.</span>selfText_assert<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">[</span><span class="token string">"百度"</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 元素文本值包含断言</span>

<span class="token comment"># 实例三</span>
keyword<span class="token punctuation">.</span>selfText_assert<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token string">""</span><span class="token punctuation">)</span>  <span class="token comment"># 元素文本为空判断</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>content形参(在用例步骤中为 “操作值” 单元格中书写的值)传入"" 代表做值为空判断。</li>
<li>如果想要进行包含值比较，则需要将要比较的预期结果用中括号“[]”包裹，如果预期结果为字符串或者汉字则必须在中括号中用引号引起来否则会出错误。</li>
<li>若直接原样传入预期结果，则关键字将进行“相等值断言比较”。</li>
<li>该关键字只支持对string类型的数据进行“包含值比较”，其它类型的数据会自动判别为“相等值比较”，例如 “传入[12]关键字会认为是对“数字12”与实际结果做相等值比较”。</li>
<li>不必担心传入的content形参(在用例步骤中为 “操作值” 单元格中书写的值)是否为string类型，关键字会自动进行类型转换例如 “传入数字5会自动转换成’5’”。</li>
</ul>
<hr>
<h4><a id="selfAttribute_assert__1857"></a>selfAttribute_assert() 关键字</h4>
<a id="selfAttribute_assert">
</a><blockquote>
<p>元素指定属性值比较断言</p>
</blockquote>
<p><strong>描述</strong><br>
对指定元素的指定值进行比较断言，若预期属性值与实际属性值一致则返回<code>True</code>反之则返回<code>False</code></p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>定位方式, 定位表达式 [, 索引位置]</td>
<td>[‘属性名’,‘预期结果’[,‘是否截取’]]</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>selfAttribute_assert</td>
<td>key1/key2</td>
<td align="left">[‘属性名’,‘预期结果’[,‘是否截取’]]</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>selfAttribute_assert</td>
<td>id/dis/xpaths…</td>
<td>对应表达式</td>
<td align="left">[‘属性名’,‘预期结果’[,‘是否截取’]]</td>
</tr>
</tbody>
</table><p><strong>元素节点数据区分 elementData.yaml文件书写示例</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># 区分元素节点数据 - “元素定位信息”elementData.yaml文件书写示例</span>
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span>  id <span class="token punctuation">|</span><span class="token punctuation">|</span> xpath <span class="token punctuation">|</span><span class="token punctuation">|</span> css_selectors …   <span class="token comment"># 框架中支持即可</span>
    <span class="token punctuation">-</span> 对应方式的定位表达式
    <span class="token punctuation">-</span> <span class="token punctuation">[</span> 0<span class="token punctuation">-</span>n <span class="token punctuation">]</span>  <span class="token comment"># index索引，在复数定位时可使用此项(定位方式末尾带有‘s’时为复数定位)；可省略</span>
</code></pre>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>selfAttribute_assert<span class="token punctuation">(</span><span class="token string">'定位方式'</span><span class="token punctuation">,</span><span class="token string">'定位表达式'</span><span class="token punctuation">,</span>content<span class="token operator">=</span><span class="token string">'断言数据'</span><span class="token punctuation">[</span><span class="token punctuation">,</span>index<span class="token operator">=</span><span class="token string">'索引值'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 元素指定属性值断言</span>

<span class="token triple-quoted-string string">'''
def selfAttribute_assert(self, targeting, element, index=None, content=None) 注意关键字在定义时的参数顺序
@ targeting: 定位方式
@ element: 定位表达式
@ index: 索引
@ content: 断言数据

注意：根据python的函数传参规则，若要按照顺序传参的方式调用关键字，则需要严格按照关键字在定义时的参数位置顺序进行参数值书写，若不按照顺序传参的方式调用关键字，则需要在调用时标明参数值的形参名称如 ‘targeting=xx’ ‘element=xx’ ‘index=xx’等等。
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>selfAttribute_assert<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">[</span><span class="token string">'百度一下'</span><span class="token punctuation">,</span><span class="token string">'value'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 元素value属性值断言</span>

<span class="token comment"># 实例二</span>
keyword<span class="token punctuation">.</span>selfAttribute_assert<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">[</span><span class="token punctuation">[</span><span class="token string">'百度'</span><span class="token punctuation">]</span><span class="token punctuation">,</span><span class="token string">'value'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 元素value属性值包含断言</span>

<span class="token comment"># 实例三</span>
keyword<span class="token punctuation">.</span>selfAttribute_assert<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">[</span><span class="token string">'baidu.jpg'</span><span class="token punctuation">,</span><span class="token string">'src'</span><span class="token punctuation">,</span> <span class="token boolean">True</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 图片元素src属性值截取断言</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>content形参(在用例步骤中为 “操作值” 单元格中书写的值)为list列表类型，列表第一项代表属性名，列表第二项代表预期结果，列表第三项代表是否对实际结果按照预期结果进行长度截取，例如 <code>['src','test2.jpeg',True]</code>。</li>
<li>对content形参(在用例步骤中为 “操作值” 单元格中书写的值)做重点解释：
<ul>
<li>列表中的第三项为布尔类型，如果为<code>True</code>则代表根据预期结果对实际结果进行长度截取，若省略不写则默认为<code>False</code>代表原样，该值主要应用在对图片或者文件路径做判断的场景下(例如预期结果：test2.jpeg、实际结果：c:\xxx\xxx\xx\test1.jpeg，截取后的实际结果为 test1.jpeg)；</li>
<li>如果想要对预期结果进行值“包含”比较则需要将预期结果用中括号“[]”包裹，如果预期结果为字符串或者汉字则必须在中括号中用引号引起来否则会出错误，例如 <code>['src',['123']]</code> 或者 <code>['src',[0]]</code>；</li>
<li>在实际调用时“实际结果长度截取”与“值包含比较”可同时使用，例如 <code>[['baidu'],'src', True]</code>；</li>
</ul>
</li>
</ul>
<hr>
<h4><a id="elementNumber_assert__1923"></a>elementNumber_assert() 关键字</h4>
<blockquote>
<p>对页面中指定元素的个数进行断言判断</p>
</blockquote>
<p><strong>描述</strong><br>
获取页面中指定元素的个数，并将其与预期个数进行断言判断；若预期个数与元素的实际个数一致则返回<code>True</code>反之则返回<code>False</code></p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>复数定位方式, 定位表达式 [, 父级对象]</td>
<td>预期个数</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>elementNumber_assert</td>
<td>key1/key2</td>
<td align="left">预期个数</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>elementNumber_assert</td>
<td>ids/xpaths…</td>
<td>对应表达式</td>
<td align="left">预期个数</td>
</tr>
</tbody>
</table><p><strong>元素节点数据区分 elementData.yaml文件书写示例</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># 区分元素节点数据 - “元素定位信息”elementData.yaml文件书写示例</span>
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span>  ids <span class="token punctuation">|</span><span class="token punctuation">|</span> xpaths <span class="token punctuation">|</span><span class="token punctuation">|</span> css_selectors …   <span class="token comment"># 框架中支持即可，只允许使用复数定位方式</span>
    <span class="token punctuation">-</span> 对应方式的定位表达式
</code></pre>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>elementNumber_assert<span class="token punctuation">(</span><span class="token string">'复数定位方式'</span><span class="token punctuation">,</span><span class="token string">'定位表达式'</span><span class="token punctuation">,</span> <span class="token string">'预期个数'</span> <span class="token punctuation">[</span><span class="token punctuation">,</span>ParentObject<span class="token operator">=</span><span class="token string">'父级元素对象'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 元素个数断言</span>

<span class="token triple-quoted-string string">'''
def elementNumber_assert(self, targeting, element, content, ParentObject=None) 注意关键字在定义时的参数顺序
@ targeting: 定位方式
@ element: 定位表达式
@ content: 预期个数
@ ParentObject: 父级element对象

注意：根据python的函数传参规则，若要按照顺序传参的方式调用关键字，则需要严格按照关键字在定义时的参数位置顺序进行参数值书写，若不按照顺序传参的方式调用关键字，则需要在调用时标明参数值的形参名称如 ‘targeting=xx’ ‘element=xx’ ‘index=xx’等等。
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>elementNumber_assert<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token number">1</span><span class="token punctuation">)</span>  <span class="token comment"># 判断指定元素是否在页面中有且仅有一个</span>

<span class="token comment"># 实例二</span>
elementObject <span class="token operator">=</span> keyword<span class="token punctuation">.</span>locator<span class="token punctuation">(</span><span class="token string">'tag_name'</span><span class="token punctuation">,</span> <span class="token string">'body'</span><span class="token punctuation">)</span>  <span class="token comment"># 父级元素定位</span>
keyword<span class="token punctuation">.</span>elementNumber_assert<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token string">'1'</span><span class="token punctuation">,</span> ParentObject<span class="token operator">=</span>elementObject<span class="token punctuation">)</span>  <span class="token comment"># 判断指定元素是否在页面中有且仅有一个</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字中仅允许采用复数定位方式，不允许使用索引值，不支持对单元素进行断言。</li>
<li>关键字content形参(在用例步骤中为 “操作值” 单元格中书写的值)中的预期个数可以是数字文本也可以是纯数字，关键字会自动对其进行类型转换你只要保证它是阿拉伯数字即可。</li>
<li>如果 content形参(在用例步骤中为 “操作值” 单元格中书写的值)中出现多个数字，则默认取获取到的第一个数字，例如 “测试12测试34” [处理后] “12”。</li>
<li>如果想要使用python表达式来计算预期结果，则需要将你的表达式包裹在中括号“[]”中传给关键字；例如 [int(‘2’) - (int(‘1’)-1)*10]。</li>
<li>若传入的为python表达式，则关键字不会进行“条目3”中所述的筛选；</li>
<li>关键字中的“父级对象”形参(后代元素定位)，主要在脚本中调用关键字时使用，用例步骤中不使用。</li>
</ul>
<hr>
<h4><a id="elementErgodic_assert__1985"></a>elementErgodic_assert() 关键字</h4>
<blockquote>
<p>对元素的某项值进行遍历比较 - 该值预期存在</p>
</blockquote>
<p><strong>描述</strong><br>
对界面指定元素的某项值进行遍历比较，该值预期存在；关键字支持两种断言模式分别为 “<strong>正常逻辑(默认)</strong>，即当前实际结果中有任意一条记录与预期结果不相等则返回<code>False</code>，如果所有记录全部相符则返回<code>True</code>”；“<strong>取反逻辑</strong>，即当前实际结果中有任意一条记录与预期结果相等则返回<code>True</code>，如果没有一条记录相符则返回<code>False</code>”</p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>复数定位方式, 定位表达式</td>
<td>[‘预期结果’[, ‘指定属性名’][, 逻辑是否取反]]</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>elementErgodic_assert</td>
<td>key1/key2</td>
<td align="left">[‘预期结果’[, ‘指定属性名’][, 逻辑是否取反]]</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>elementErgodic_assert</td>
<td>ids/xpaths…</td>
<td>对应表达式</td>
<td align="left">[‘预期结果’[, ‘指定属性名’][, 逻辑是否取反]]</td>
</tr>
</tbody>
</table><p><strong>元素节点数据区分 elementData.yaml文件书写示例</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># 区分元素节点数据 - “元素定位信息”elementData.yaml文件书写示例</span>
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span>  ids <span class="token punctuation">|</span><span class="token punctuation">|</span> xpaths <span class="token punctuation">|</span><span class="token punctuation">|</span> css_selectors …   <span class="token comment"># 框架中支持即可，只允许使用复数定位方式</span>
    <span class="token punctuation">-</span> 对应方式的定位表达式
</code></pre>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>elementErgodic_assert<span class="token punctuation">(</span><span class="token string">'复数定位方式'</span><span class="token punctuation">,</span><span class="token string">'定位表达式'</span><span class="token punctuation">,</span><span class="token punctuation">[</span><span class="token string">'预期结果'</span><span class="token punctuation">[</span><span class="token punctuation">,</span><span class="token string">'指定属性名'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token punctuation">,</span><span class="token string">'是否取反'</span><span class="token punctuation">]</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 元素指定值遍历比较断言</span>

<span class="token triple-quoted-string string">'''
def elementErgodic_assert(self, targeting, element, content) 注意关键字在定义时的参数顺序
@ targeting: 定位方式
@ element: 定位表达式
@ content: 断言数据信息
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>elementErgodic_assert<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">[</span><span class="token string">'自动化'</span><span class="token punctuation">,</span><span class="token string">'value'</span><span class="token punctuation">,</span><span class="token boolean">False</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 对界面所有id属性值为kw的元素的value属性值进行遍历，验证是否存在一个值为'自动化'的元素</span>

<span class="token comment"># 实例二</span>
keyword<span class="token punctuation">.</span>elementErgodic_assert<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">[</span><span class="token string">'自动化'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 对界面所有id属性值为kw的元素的text文本值进行遍历，验证值是否均为'自动化'</span>

<span class="token comment"># 实例三</span>
keyword<span class="token punctuation">.</span>elementErgodic_assert<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">[</span><span class="token string">'自动化'</span><span class="token punctuation">,</span> <span class="token boolean">False</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 对界面所有id属性值为kw的元素的text文本值进行遍历，验证是否存在一个值为'自动化'的元素</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字中仅允许采用复数定位方式，不允许使用索引值，不对单元素定位进行操作。</li>
<li>content形参(在用例步骤中为 “操作值” 单元格中书写的值)应为list类型：
<ul>
<li>列表第一项为要进行比较的预期结果值，如果想要对预期结果进行值“包含”比较，则需要将要比较的预期结果用中括号“[]”包裹，如果预期结果为字符串或者汉字则必须在中括号中用引号引起来，否则会出错误；例如 [‘123’]、[0]。</li>
<li>列表第二项为要获取元素的那个属性值，如 <code>value</code> / <code>class</code>…如果省略则默认为text文本值，属性名需用引号引起来，例如 [‘123’,‘src’]、[‘123’]。</li>
<li>列表第三项为布尔值代表取反逻辑标识，如果省略则默认为<code>True</code>，例如 [‘123’,‘src’,True] 、[‘123’,False]。</li>
</ul>
</li>
<li>逻辑取反<code>True(默认)</code>，即当前实际结果中有任意一条记录与预期结果不相等则返回<code>False</code>，如果所有记录全部相符则返回<code>True</code>”。</li>
<li>逻辑取反<code>False</code>，即当前实际结果中有任意一条记录与预期结果相等则返回<code>True</code>，如果没有一条记录相符则返回<code>False</code>”。</li>
</ul>
<hr>
<h4><a id="elementErgodicNot_assert__2047"></a>elementErgodicNot_assert() 关键字</h4>
<blockquote>
<p>对元素的某项值进行遍历比较 - 该值预期不存在</p>
</blockquote>
<p><strong>描述</strong><br>
对界面指定元素的某项值进行遍历比较，该值预期不存在；当前实际结果中有任意一条记录与预期结果相等则返回<code>False</code>，如果所有记录均不相符则返回<code>True</code></p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>复数定位方式, 定位表达式</td>
<td>[‘预期结果’[, ‘指定属性名’]]</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>elementErgodicNot_assert</td>
<td>key1/key2</td>
<td align="left">[‘预期结果’[, ‘指定属性名’]]</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>elementErgodicNot_assert</td>
<td>ids/xpaths…</td>
<td>对应表达式</td>
<td align="left">[‘预期结果’[, ‘指定属性名’]]</td>
</tr>
</tbody>
</table><p><strong>元素节点数据区分 elementData.yaml文件书写示例</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># 区分元素节点数据 - “元素定位信息”elementData.yaml文件书写示例</span>
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span>  ids <span class="token punctuation">|</span><span class="token punctuation">|</span> xpaths <span class="token punctuation">|</span><span class="token punctuation">|</span> css_selectors …   <span class="token comment"># 框架中支持即可，只允许使用复数定位方式</span>
    <span class="token punctuation">-</span> 对应方式的定位表达式
</code></pre>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>elementErgodicNot_assert<span class="token punctuation">(</span><span class="token string">'复数定位方式'</span><span class="token punctuation">,</span><span class="token string">'定位表达式'</span><span class="token punctuation">,</span><span class="token punctuation">[</span><span class="token string">'预期结果'</span><span class="token punctuation">[</span><span class="token punctuation">,</span><span class="token string">'指定属性名'</span><span class="token punctuation">]</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 元素指定值遍历比较断言</span>

<span class="token triple-quoted-string string">'''
def elementErgodicNot_assert(self, targeting, element, content) 注意关键字在定义时的参数顺序
@ targeting: 定位方式
@ element: 定位表达式
@ content: 断言数据信息
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>elementErgodicNot_assert<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">[</span><span class="token string">'自动化'</span><span class="token punctuation">,</span><span class="token string">'value'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 对界面所有id属性值为kw的元素的value属性值进行遍历，验证值是否均不为'自动化'</span>

<span class="token comment"># 实例二</span>
keyword<span class="token punctuation">.</span>elementErgodicNot_assert<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">[</span><span class="token string">'自动化'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 对界面所有id属性值为kw的元素的text文本值进行遍历，验证值是否均不为'自动化'</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字中仅允许采用复数定位方式，不允许使用索引值，不对单元素定位进行操作。</li>
<li>content形参(在用例步骤中为 “操作值” 单元格中书写的值)应为list类型：
<ul>
<li>列表第一项为要进行比较的预期结果值，如果想要对预期结果进行值“包含”比较，则需要将要比较的预期结果用中括号“[]”包裹，如果预期结果为字符串或者汉字则必须在中括号中用引号引起来，否则会出错误；例如 [‘123’]、[0]</li>
<li>列表第二项为要获取元素的那个属性值，如 <code>value</code> / <code>class</code>…如果省略则默认为text文本值，属性名需用引号引起来，例如 [‘123’,‘src’]、[‘123’]</li>
</ul>
</li>
</ul>
<hr>
<h4><a id="elementExistence_assert__2103"></a>elementExistence_assert() 关键字</h4>
<a id="elementExistence_assert">
</a><blockquote>
<p>断言指定元素是否存在(指定元素是否存在于DOM树中并可见)</p>
</blockquote>
<p><strong>描述</strong><br>
断言判断指定的元素是否存在(指定元素是否存在于DOM树中，可见且元素的高和宽都大于0)；关键字支持两种断言模式分别为 “<strong>True</strong>，元素存在返回<code>True</code>不存在则返回<code>False</code>” 和 “<strong>False(默认)</strong>，元素存在返回<code>False</code>不存在则返回<code>True</code>”</p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>定位方式, 定位表达式 [, 索引位置][, 父级对象]</td>
<td>True / False / 空</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>elementExistence_assert</td>
<td>key1/key2</td>
<td align="left">True / False / 空</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>elementExistence_assert</td>
<td>id/dis/xpaths…</td>
<td>对应表达式</td>
<td align="left">True / False / 空</td>
</tr>
</tbody>
</table><p><strong>元素节点数据区分 elementData.yaml文件书写示例</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># 区分元素节点数据 - “元素定位信息”elementData.yaml文件书写示例</span>
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span>  id <span class="token punctuation">|</span><span class="token punctuation">|</span> xpath <span class="token punctuation">|</span><span class="token punctuation">|</span> css_selectors …   <span class="token comment"># 框架中支持即可</span>
    <span class="token punctuation">-</span> 对应方式的定位表达式
    <span class="token punctuation">-</span> <span class="token punctuation">[</span> 0<span class="token punctuation">-</span>n <span class="token punctuation">]</span>  <span class="token comment"># index索引，在复数定位时可使用此项(定位方式末尾带有‘s’时为复数定位)；可省略</span>
</code></pre>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>elementExistence_assert<span class="token punctuation">(</span><span class="token string">'定位方式'</span><span class="token punctuation">,</span><span class="token string">'定位表达式'</span><span class="token punctuation">[</span><span class="token punctuation">,</span>index<span class="token operator">=</span><span class="token string">'索引值'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token punctuation">,</span>ParentObject<span class="token operator">=</span><span class="token string">'父级元素对象'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token punctuation">,</span>content<span class="token operator">=</span><span class="token string">'断言方式'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 元素存在与否断言</span>

<span class="token triple-quoted-string string">'''
def elementExistence_assert(self, targeting, element, index=None, ParentObject=None, content=None) 注意关键字在定义时的参数顺序
@ targeting: 定位方式
@ element: 定位表达式
@ index: 索引
@ ParentObject: 父级element对象
@ content: 断言逻辑类型

注意：根据python的函数传参规则，若要按照顺序传参的方式调用关键字，则需要严格按照关键字在定义时的参数位置顺序进行参数值书写，若不按照顺序传参的方式调用关键字，则需要在调用时标明参数值的形参名称如 ‘targeting=xx’ ‘element=xx’ ‘index=xx’等等。
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>elementExistence_assert<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token boolean">True</span><span class="token punctuation">)</span>  <span class="token comment"># 判断界面id属性值为kw的元素是否存在</span>

<span class="token comment"># 实例二</span>
keyword<span class="token punctuation">.</span>elementExistence_assert<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">)</span>  <span class="token comment"># 判断界面id属性值为kw的元素是否不存在</span>

<span class="token comment"># 实例三</span>
elementObject <span class="token operator">=</span> keyword<span class="token punctuation">.</span>locator<span class="token punctuation">(</span><span class="token string">'tag_name'</span><span class="token punctuation">,</span> <span class="token string">'body'</span><span class="token punctuation">)</span>  <span class="token comment"># 父级元素定位</span>
keyword<span class="token punctuation">.</span>elementExistence_assert<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> ParentObject<span class="token operator">=</span>elementObject<span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token boolean">True</span><span class="token punctuation">)</span>  <span class="token comment"># 判断界面id属性值为kw的元素是否存在</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>content形参(在用例步骤中为 “操作值” 单元格中书写的值)为布尔类型，代表关键字的判定依据“<code>True</code>：指定元素预期存在”、“<code>False(默认)</code>：指定元素预期不存在”。</li>
<li>若content形参(在用例步骤中为 “操作值” 单元格中书写的值)为空则关键字按False“指定元素预期不存在”做断言。</li>
<li>关键字中的“父级对象”形参(后代元素定位)，主要在脚本中调用关键字时使用，用例步骤中不使用。</li>
</ul>
<hr>
<h4><a id="elementComparison_assert__2169"></a>elementComparison_assert() 关键字</h4>
<blockquote>
<p>元素指定值大小比较断言</p>
</blockquote>
<p><strong>描述</strong><br>
对元素指定值的大小进行比较断言，支持对 “单个元素” 和 “复数元素” 进行关系运算(&lt;, &gt;, &gt;=, &lt;=, ==)。若表达式成立则返回<code>True</code>不成立则返回<code>False</code></p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>定位方式, 定位表达式 [, 索引位置]</td>
<td>预期值 / [‘预期值’, ‘关系运算符’[, ‘属性名’]]</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>elementComparison_assert</td>
<td>key1/key2</td>
<td align="left">预期值 / [‘预期值’, ‘关系运算符’[,‘属性名’]]</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>elementComparison_assert</td>
<td>id/dis/xpaths…</td>
<td>对应表达式</td>
<td align="left">预期值 / [‘预期值’, ‘关系运算符’[,‘属性名’]]</td>
</tr>
</tbody>
</table><p><strong>元素节点数据区分 elementData.yaml文件书写示例</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># 区分元素节点数据 - “元素定位信息”elementData.yaml文件书写示例</span>
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span>  id <span class="token punctuation">|</span><span class="token punctuation">|</span> xpath <span class="token punctuation">|</span><span class="token punctuation">|</span> css_selectors …   <span class="token comment"># 框架中支持即可</span>
    <span class="token punctuation">-</span> 对应方式的定位表达式
    <span class="token punctuation">-</span> <span class="token punctuation">[</span> 0<span class="token punctuation">-</span>n <span class="token punctuation">]</span>  <span class="token comment"># index索引，在复数定位时可使用此项(定位方式末尾带有‘s’时为复数定位)；可省略</span>
</code></pre>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>elementComparison_assert<span class="token punctuation">(</span><span class="token string">'定位方式'</span><span class="token punctuation">,</span><span class="token string">'定位表达式'</span><span class="token punctuation">[</span><span class="token punctuation">,</span>index<span class="token operator">=</span><span class="token string">'索引值'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token punctuation">,</span>content<span class="token operator">=</span><span class="token string">'断言参数'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 元素指定值大小值比较</span>

<span class="token triple-quoted-string string">'''
def elementComparison_assert(self, targeting, element, index=None, content=None) 注意关键字在定义时的参数顺序
@ targeting: 定位方式
@ element: 定位表达式
@ index: 索引
@ content: 断言参数

注意：根据python的函数传参规则，若要按照顺序传参的方式调用关键字，则需要严格按照关键字在定义时的参数位置顺序进行参数值书写，若不按照顺序传参的方式调用关键字，则需要在调用时标明参数值的形参名称如 ‘targeting=xx’ ‘element=xx’ ‘index=xx’等等。
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>elementComparison_assert<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">[</span><span class="token number">123</span><span class="token punctuation">,</span> <span class="token string">'&gt;='</span><span class="token punctuation">,</span> <span class="token string">'value'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 判断界面所有id属性值为kw的元素的value属性值是否均 &gt;= 123</span>

<span class="token comment"># 实例二</span>
keyword<span class="token punctuation">.</span>elementComparison_assert<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">[</span><span class="token number">123</span><span class="token punctuation">,</span> <span class="token string">'&lt;'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 判断界面id属性值为kw的元素的text文本值是否 &lt; 123</span>

<span class="token comment"># 实例三</span>
keyword<span class="token punctuation">.</span>elementComparison_assert<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token number">123</span><span class="token punctuation">)</span>  <span class="token comment"># 判断界面id属性值为kw的元素的text文本值是否 &gt; 123</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字同时支持对 “单个元素” 和 “复数元素” 进行操作，关键字会根据实际传入的“定位方式”进行判断，无需特殊指明。</li>
<li>关键字的比较值为“实际结果”，例如 “实际结果 &gt; 预期结果”、“实际结果 &lt; 预期结果”…，要注意传入的关系运算符是否对应有效。</li>
<li>content形参(在用例步骤中为 “操作值” 单元格中书写的值)可接收 “<code>string</code>” 和 “<code>list</code>” 两种类型的参数，代表要进行操作的表达式。
<ul>
<li>“<code>string</code>” 类型，代表要进行比较的预期结果；关键字将默认以 “&gt;大于” 对预期结果和实际结果(指定元素的text文本值)进行比较；</li>
<li>“<code>list</code>” 类型，[‘预期结果’, ‘关系运算符’, [‘属性名’]]，表示要对指定元素的某个预期属性值进行某种关系的比较；列表首项代表“预期结果”，第二项代表要关键字进行何种“关系运算”，第三项则代表要关键字对指定元素的那个“属性”的值做比较(可省略，若省略则默认取元素的“text文本值”)；</li>
<li>“<code>list类型</code>” 两种合法传值举例： <code>['预期结果', '关系运算符']</code>  ||  <code>['预期结果', '关系运算符', '属性名']</code>，注意除“预期结果”为非字符串和汉字时不需要用引号标注，其它情况下“list列表”中的各项均需要用引号标注；</li>
</ul>
</li>
</ul>
<hr>
<h4><a id="functionReturn_assert__2234"></a>functionReturn_assert() 关键字</h4>
<blockquote>
<p>自定义插件方法返还结果断言</p>
</blockquote>
<p><strong>描述</strong><br>
按照需求调用指定的插件方法，并对插件方法的返还<code>return</code>结果进行断言判断，若预期结果与实际结果一致则返回<code>True</code>反之则返回<code>False</code></p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>无</td>
<td>[‘预计比对结果文本’,‘[插件名]方法名’[,插件方法参数]]</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>functionReturn_assert</td>
<td></td>
<td align="left">[‘预期比对结果’,‘[插件名]方法名’[,插件方法参数]]</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>functionReturn_assert</td>
<td></td>
<td></td>
<td align="left">[‘预期比对结果’,‘[插件名]方法名’[,插件方法参数]]</td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<blockquote>
<p><font color="red"> 关键字不支持在脚本中使用</font></p>
</blockquote>
<p><strong>注意事项</strong></p>
<ul>
<li>content形参(在用例步骤中为 “操作值” 单元格中书写的值)为list列表类型存放三个值：
<ul>
<li>第一个值为要进行比较的预期结果；</li>
<li>第二个值为要进行调用的插件方法名，按照“[插件名]方法名”的方式书写；</li>
<li>第三个值为插件方法的参数列表，支持采用list(顺序传递)和dict(指定参数)两种方式传参；若无需参数时该项可省略不写；</li>
</ul>
</li>
<li>content形参(在用例步骤中为 “操作值” 单元格中书写的值)书写示例：</li>
</ul>
<pre><code class="prism language-python"><span class="token punctuation">[</span><span class="token string">'预计比对结果'</span><span class="token punctuation">,</span><span class="token string">'[插件名]方法名'</span><span class="token punctuation">,</span><span class="token punctuation">[</span><span class="token string">'1'</span><span class="token punctuation">,</span><span class="token string">'2'</span><span class="token punctuation">,</span><span class="token string">'3'</span><span class="token punctuation">]</span><span class="token punctuation">]</span>  <span class="token comment"># 插件方法带参调用，并按照list(顺序传递)方式将参数传递给插件方法。</span>
<span class="token punctuation">[</span><span class="token string">'预计比对结果文本'</span><span class="token punctuation">,</span><span class="token string">'[插件名]方法名'</span><span class="token punctuation">,</span><span class="token punctuation">{</span><span class="token string">'参数1'</span><span class="token punctuation">:</span><span class="token string">'1'</span><span class="token punctuation">,</span> <span class="token string">'参数3'</span><span class="token punctuation">:</span><span class="token string">'3'</span><span class="token punctuation">,</span> <span class="token string">'参数2'</span><span class="token punctuation">:</span><span class="token string">'2'</span><span class="token punctuation">}</span><span class="token punctuation">]</span>  <span class="token comment"># 插件方法带参调用，并按照dict(指定参数)方式将参数传递给插件方法。</span>
<span class="token punctuation">[</span><span class="token string">'预计比对结果'</span><span class="token punctuation">,</span><span class="token string">'[插件名]方法名'</span><span class="token punctuation">]</span>  <span class="token comment"># 插件方法无参调用</span>
</code></pre>
<hr>
<h4><a id="downloadExport_assert__2270"></a>downloadExport_assert() 关键字</h4>
<blockquote>
<p>文件下载/导出断言判断</p>
</blockquote>
<p><strong>描述</strong><br>
对下载或者导出的项(文件)进行断言判断，若预期文件名与实际文件名一致则返回<code>True</code>反之则返回<code>False</code></p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>无</td>
<td>预期文件名.xxx / [‘预期文件名.xxx’]</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em><br>
文件名应带有拓展名 xxx.xx</p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>downloadExport_assert</td>
<td></td>
<td align="left">预期文件名.xxx / [‘预期文件名.xxx’]</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>downloadExport_assert</td>
<td></td>
<td></td>
<td align="left">预期文件名.xxx / [‘预期文件名.xxx’]</td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>downloadExport_assert<span class="token punctuation">(</span><span class="token string">'预期文件名'</span><span class="token punctuation">)</span>  <span class="token comment"># 文件下载导出检查</span>

<span class="token triple-quoted-string string">'''
downloadExport_assert(self, prospectiveControl) 注意关键字在定义时的参数顺序
@ prospectiveControl: 预期对照文件名，文件名中应包含拓展名
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>downloadExport_assert<span class="token punctuation">(</span><span class="token string">'查询结果.txt'</span><span class="token punctuation">)</span>  <span class="token comment"># 导出文件名断言</span>

<span class="token comment"># 实例二</span>
keyword<span class="token punctuation">.</span>downloadExport_assert<span class="token punctuation">(</span>prospectiveControl<span class="token operator">=</span><span class="token punctuation">[</span><span class="token string">'查询结果'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 导出文件名断言</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>content形参(在用例步骤中为 “操作值” 单元格中书写的值)应为<code>string</code>类型代表预期对照值(文件名)；若需要进行包含值比较则需要将要比较的预期对照值用中括号“[]”包裹，如果预期结果为字符串或者汉字则必须在中括号中用引号引起来否则会出错误。</li>
</ul>
<hr>
<h3><a id="_2313"></a>鼠标、键盘类</h3>
<h4><a id="actionBuilder_Move__2314"></a>actionBuilder_Move() 关键字</h4>
<a id="actionBuilder_Move">
</a><blockquote>
<p>鼠标悬停</p>
</blockquote>
<p><strong>描述</strong><br>
在指定的元素上悬停鼠标</p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>定位方式, 定位表达式 [, 索引位置][, 父级对象]</td>
<td>无</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>actionBuilder_Move</td>
<td>key1/key2</td>
<td align="left"></td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>actionBuilder_Move</td>
<td>id/dis/xpaths…</td>
<td>对应表达式</td>
<td align="left"></td>
</tr>
</tbody>
</table><p><strong>元素节点数据区分 elementData.yaml文件书写示例</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># 区分元素节点数据 - “元素定位信息”elementData.yaml文件书写示例</span>
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span>  id <span class="token punctuation">|</span><span class="token punctuation">|</span> xpath <span class="token punctuation">|</span><span class="token punctuation">|</span> css_selectors …   <span class="token comment"># 框架中支持即可</span>
    <span class="token punctuation">-</span> 对应方式的定位表达式
    <span class="token punctuation">-</span> <span class="token punctuation">[</span> 0<span class="token punctuation">-</span>n <span class="token punctuation">]</span>  <span class="token comment"># index索引，在复数定位时可使用此项(定位方式末尾带有‘s’时为复数定位)；可省略</span>
</code></pre>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>actionBuilder_Move<span class="token punctuation">(</span><span class="token string">'定位方式'</span><span class="token punctuation">,</span><span class="token string">'定位表达式'</span><span class="token punctuation">[</span><span class="token punctuation">,</span>index<span class="token operator">=</span><span class="token string">'索引值'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token punctuation">,</span>ParentObject<span class="token operator">=</span><span class="token string">'父级对象'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 鼠标悬停</span>

<span class="token triple-quoted-string string">'''
def actionBuilder_Move(self, targeting, element, index=None, ParentObject=None) 注意关键字在定义时的参数顺序
@ targeting: 定位方式
@ element: 定位表达式
@ index: 索引
@ ParentObject: 父级元素对象

注意：根据python的函数传参规则，若要按照顺序传参的方式调用关键字，则需要严格按照关键字在定义时的参数位置顺序进行参数值书写，若不按照顺序传参的方式调用关键字，则需要在调用时标明参数值的形参名称如 ‘targeting=xx’ ‘element=xx’ ‘index=xx’等等。
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>actionBuilder_Move<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">)</span>  <span class="token comment"># 鼠标悬停</span>

<span class="token comment"># 实例二</span>
elementObject <span class="token operator">=</span> keyword<span class="token punctuation">.</span>locator<span class="token punctuation">(</span><span class="token string">'tag_name'</span><span class="token punctuation">,</span> <span class="token string">'body'</span><span class="token punctuation">)</span>  <span class="token comment"># 父级元素定位</span>
keyword<span class="token punctuation">.</span>actionBuilder_Move<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">,</span> ParentObject<span class="token operator">=</span>elementObject <span class="token punctuation">)</span>  <span class="token comment"># 鼠标悬停</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字中的“父级对象”形参(后代元素定位)，主要在脚本中调用关键字时使用，用例步骤中不使用。</li>
</ul>
<hr>
<h4><a id="actionBuilder_RightClick__2374"></a>actionBuilder_RightClick() 关键字</h4>
<a id="actionBuilder_RightClick">
</a><blockquote>
<p>鼠标右击</p>
</blockquote>
<p><strong>描述</strong><br>
在指定的元素上右击鼠标</p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>定位方式, 定位表达式 [, 索引位置][, 父级对象]</td>
<td>无</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>actionBuilder_RightClick</td>
<td>key1/key2</td>
<td align="left"></td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>actionBuilder_RightClick</td>
<td>id/dis/xpaths…</td>
<td>对应表达式</td>
<td align="left"></td>
</tr>
</tbody>
</table><p><strong>元素节点数据区分 elementData.yaml文件书写示例</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># 区分元素节点数据 - “元素定位信息”elementData.yaml文件书写示例</span>
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span>  id <span class="token punctuation">|</span><span class="token punctuation">|</span> xpath <span class="token punctuation">|</span><span class="token punctuation">|</span> css_selectors …   <span class="token comment"># 框架中支持即可</span>
    <span class="token punctuation">-</span> 对应方式的定位表达式
    <span class="token punctuation">-</span> <span class="token punctuation">[</span> 0<span class="token punctuation">-</span>n <span class="token punctuation">]</span>  <span class="token comment"># index索引，在复数定位时可使用此项(定位方式末尾带有‘s’时为复数定位)；可省略</span>
</code></pre>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>actionBuilder_RightClick<span class="token punctuation">(</span><span class="token string">'定位方式'</span><span class="token punctuation">,</span><span class="token string">'定位表达式'</span><span class="token punctuation">[</span><span class="token punctuation">,</span>index<span class="token operator">=</span><span class="token string">'索引值'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token punctuation">,</span>ParentObject<span class="token operator">=</span><span class="token string">'父级对象'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 鼠标右击</span>

<span class="token triple-quoted-string string">'''
def actionBuilder_RightClick(self, targeting, element, index=None, ParentObject=None) 注意关键字在定义时的参数顺序
@ targeting: 定位方式
@ element: 定位表达式
@ index: 索引
@ ParentObject: 父级元素对象

注意：根据python的函数传参规则，若要按照顺序传参的方式调用关键字，则需要严格按照关键字在定义时的参数位置顺序进行参数值书写，若不按照顺序传参的方式调用关键字，则需要在调用时标明参数值的形参名称如 ‘targeting=xx’ ‘element=xx’ ‘index=xx’等等。
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>actionBuilder_RightClick<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">)</span>  <span class="token comment"># 鼠标右击</span>

<span class="token comment"># 实例二</span>
elementObject <span class="token operator">=</span> keyword<span class="token punctuation">.</span>locator<span class="token punctuation">(</span><span class="token string">'tag_name'</span><span class="token punctuation">,</span> <span class="token string">'body'</span><span class="token punctuation">)</span>  <span class="token comment"># 父级元素定位</span>
keyword<span class="token punctuation">.</span>actionBuilder_RightClick<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">,</span> ParentObject<span class="token operator">=</span>elementObject <span class="token punctuation">)</span>  <span class="token comment"># 鼠标右击</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字中的“父级对象”形参(后代元素定位)，主要在脚本中调用关键字时使用，用例步骤中不使用。</li>
</ul>
<hr>
<h4><a id="actionBuilder_DoubleClick__2434"></a>actionBuilder_DoubleClick() 关键字</h4>
<a id="actionBuilder_DoubleClick">
</a><blockquote>
<p>鼠标双击</p>
</blockquote>
<p><strong>描述</strong><br>
在指定的元素上双击鼠标</p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>定位方式, 定位表达式 [, 索引位置][, 父级对象]</td>
<td>无</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>actionBuilder_DoubleClick</td>
<td>key1/key2</td>
<td align="left"></td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>actionBuilder_DoubleClick</td>
<td>id/dis/xpaths…</td>
<td>对应表达式</td>
<td align="left"></td>
</tr>
</tbody>
</table><p><strong>元素节点数据区分 elementData.yaml文件书写示例</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># 区分元素节点数据 - “元素定位信息”elementData.yaml文件书写示例</span>
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span>  id <span class="token punctuation">|</span><span class="token punctuation">|</span> xpath <span class="token punctuation">|</span><span class="token punctuation">|</span> css_selectors …   <span class="token comment"># 框架中支持即可</span>
    <span class="token punctuation">-</span> 对应方式的定位表达式
    <span class="token punctuation">-</span> <span class="token punctuation">[</span> 0<span class="token punctuation">-</span>n <span class="token punctuation">]</span>  <span class="token comment"># index索引，在复数定位时可使用此项(定位方式末尾带有‘s’时为复数定位)；可省略</span>
</code></pre>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>actionBuilder_DoubleClick<span class="token punctuation">(</span><span class="token string">'定位方式'</span><span class="token punctuation">,</span><span class="token string">'定位表达式'</span><span class="token punctuation">[</span><span class="token punctuation">,</span>index<span class="token operator">=</span><span class="token string">'索引值'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token punctuation">,</span>ParentObject<span class="token operator">=</span><span class="token string">'父级对象'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 鼠标双击</span>

<span class="token triple-quoted-string string">'''
def actionBuilder_DoubleClick(self, targeting, element, index=None, ParentObject=None) 注意关键字在定义时的参数顺序
@ targeting: 定位方式
@ element: 定位表达式
@ index: 索引
@ ParentObject: 父级元素对象

注意：根据python的函数传参规则，若要按照顺序传参的方式调用关键字，则需要严格按照关键字在定义时的参数位置顺序进行参数值书写，若不按照顺序传参的方式调用关键字，则需要在调用时标明参数值的形参名称如 ‘targeting=xx’ ‘element=xx’ ‘index=xx’等等。
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>actionBuilder_DoubleClick<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">)</span>  <span class="token comment"># 鼠标双击</span>

<span class="token comment"># 实例二</span>
elementObject <span class="token operator">=</span> keyword<span class="token punctuation">.</span>locator<span class="token punctuation">(</span><span class="token string">'tag_name'</span><span class="token punctuation">,</span> <span class="token string">'body'</span><span class="token punctuation">)</span>  <span class="token comment"># 父级元素定位</span>
keyword<span class="token punctuation">.</span>actionBuilder_DoubleClick<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">,</span> ParentObject<span class="token operator">=</span>elementObject <span class="token punctuation">)</span>  <span class="token comment"># 鼠标双击</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字中的“父级对象”形参(后代元素定位)，主要在脚本中调用关键字时使用，用例步骤中不使用。</li>
</ul>
<hr>
<h4><a id="keyBoard_Events__2494"></a>keyBoard_Events() 关键字</h4>
<a id="keyBoard_Events">
</a><blockquote>
<p>键盘按键模拟</p>
</blockquote>
<p><strong>描述</strong><br>
在指定的元素上模拟键盘按键点击</p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>定位方式, 定位表达式 [, 索引位置][, 父级对象]</td>
<td>键盘按键标识</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>keyBoard_Events</td>
<td>key1/key2</td>
<td align="left">键盘按键标识</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>keyBoard_Events</td>
<td>id/dis/xpaths…</td>
<td>对应表达式</td>
<td align="left">键盘按键标识</td>
</tr>
</tbody>
</table><p><strong>元素节点数据区分 elementData.yaml文件书写示例</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># 区分元素节点数据 - “元素定位信息”elementData.yaml文件书写示例</span>
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span>  id <span class="token punctuation">|</span><span class="token punctuation">|</span> xpath <span class="token punctuation">|</span><span class="token punctuation">|</span> css_selectors …   <span class="token comment"># 框架中支持即可</span>
    <span class="token punctuation">-</span> 对应方式的定位表达式
    <span class="token punctuation">-</span> <span class="token punctuation">[</span> 0<span class="token punctuation">-</span>n <span class="token punctuation">]</span>  <span class="token comment"># index索引，在复数定位时可使用此项(定位方式末尾带有‘s’时为复数定位)；可省略</span>
</code></pre>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>keyBoard_Events<span class="token punctuation">(</span><span class="token string">'定位方式'</span><span class="token punctuation">,</span><span class="token string">'定位表达式'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token string">'键盘按键标识'</span><span class="token punctuation">[</span><span class="token punctuation">,</span>index<span class="token operator">=</span><span class="token string">'索引值'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token punctuation">,</span>ParentObject<span class="token operator">=</span><span class="token string">'父级对象'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 键盘按键模拟点击</span>

<span class="token triple-quoted-string string">'''
def keyBoard_Events(self, targeting, element, index=None, content=None, ParentObject=None) 注意关键字在定义时的参数顺序
@ targeting: 定位方式
@ element: 定位表达式
@ index: 索引
@ content: 键盘按键标识
@ ParentObject: 父级元素对象

注意：根据python的函数传参规则，若要按照顺序传参的方式调用关键字，则需要严格按照关键字在定义时的参数位置顺序进行参数值书写，若不按照顺序传参的方式调用关键字，则需要在调用时标明参数值的形参名称如 ‘targeting=xx’ ‘element=xx’ ‘index=xx’等等。
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>keyBoard_Events<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token string">'Keys.ENTER'</span><span class="token punctuation">)</span>  <span class="token comment"># 模拟键盘‘回车’键点击</span>
<span class="token comment"># 实例二</span>
elementObject <span class="token operator">=</span> keyword<span class="token punctuation">.</span>locator<span class="token punctuation">(</span><span class="token string">'tag_name'</span><span class="token punctuation">,</span> <span class="token string">'body'</span><span class="token punctuation">)</span>  <span class="token comment"># 父级元素定位</span>
keyword<span class="token punctuation">.</span>keyBoard_Events<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token string">'Keys.BACK_SPACE'</span><span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">,</span> ParentObject<span class="token operator">=</span>elementObject<span class="token punctuation">)</span>  <span class="token comment"># 模拟键盘‘退格’键点击</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>content形参(在用例步骤中为 “操作值” 单元格中书写的值)如果为“退格键标识”则关键字会自动根据操作元素中的文字数量进行相应次数的按键点击。</li>
<li>部分键盘按键标识：<code>Keys.BACK_SPACE  退格键</code>、<code>Keys.ENTER  回车键</code>、<code>Keys.SPACE 空格键</code>、<code>Keys.ESCAPE  esc键</code>。</li>
<li>关键字中的“父级对象”形参(后代元素定位)，主要在脚本中调用关键字时使用，用例步骤中不使用。</li>
</ul>
<hr>
<h3><a id="_2556"></a>数据缓存</h3>
<h4><a id="getElementText__2557"></a>getElementText() 关键字</h4>
<a id="getElementText">
</a><blockquote>
<p>获取元素数据值，并存入缓存</p>
</blockquote>
<p><strong>描述</strong><br>
获取指定元素的某个属性值或者text文本值，并将获取到的数据值存入到缓存中</p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>定位方式, 定位表达式 [, 索引位置]</td>
<td>[[‘key键名’][,‘属性名’][,‘筛选类型’]] / key键名 / 属性名 / 筛选类型 / 空</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>getElementText</td>
<td>key1/key2</td>
<td align="left">[[‘key键名’][,‘属性名’][,‘筛选类型’]] / key键名 / 属性名 / 筛选类型 / 空</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>getElementText</td>
<td>id/dis/xpaths…</td>
<td>对应表达式</td>
<td align="left">[[‘key键名’][,‘属性名’][,‘筛选类型’]] / key键名 / 属性名 / 筛选类型 / 空</td>
</tr>
</tbody>
</table><p><strong>元素节点数据区分 elementData.yaml文件书写示例</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># 区分元素节点数据 - “元素定位信息”elementData.yaml文件书写示例</span>
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span>  id <span class="token punctuation">|</span><span class="token punctuation">|</span> xpath <span class="token punctuation">|</span><span class="token punctuation">|</span> css_selectors …   <span class="token comment"># 框架中支持即可</span>
    <span class="token punctuation">-</span> 对应方式的定位表达式
    <span class="token punctuation">-</span> <span class="token punctuation">[</span> 0<span class="token punctuation">-</span>n <span class="token punctuation">]</span>  <span class="token comment"># index索引，在复数定位时可使用此项(定位方式末尾带有‘s’时为复数定位)；可省略</span>
</code></pre>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>getElementText<span class="token punctuation">(</span><span class="token string">'定位方式'</span><span class="token punctuation">,</span><span class="token string">'定位表达式'</span><span class="token punctuation">[</span><span class="token punctuation">,</span>index<span class="token operator">=</span><span class="token string">'索引值'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token punctuation">,</span>content<span class="token operator">=</span><span class="token string">'操作依据'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 元素数据值缓存</span>

<span class="token triple-quoted-string string">'''
def getElementText(self, targeting, element, index=None, content=None) 注意关键字在定义时的参数顺序
@ targeting: 定位方式
@ element: 定位表达式
@ index: 索引
@ content: 操作依据

注意：根据python的函数传参规则，若要按照顺序传参的方式调用关键字，则需要严格按照关键字在定义时的参数位置顺序进行参数值书写，若不按照顺序传参的方式调用关键字，则需要在调用时标明参数值的形参名称如 ‘targeting=xx’ ‘element=xx’ ‘index=xx’等等。
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>getElementText<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">)</span>  <span class="token comment"># 元素text文本值获取，缓存key键默认</span>

<span class="token comment"># 实例二</span>
keyword<span class="token punctuation">.</span>getElementText<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token string">'value'</span><span class="token punctuation">)</span>  <span class="token comment"># 元素value属性值获取，缓存key键默认</span>

<span class="token comment"># 实例三</span>
keyword<span class="token punctuation">.</span>getElementText<span class="token punctuation">(</span><span class="token string">'id'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token string">'key123'</span><span class="token punctuation">)</span>  <span class="token comment"># 元素text文本值获取，缓存key键为“key123”</span>

<span class="token comment"># 实例四</span>
keyword<span class="token punctuation">.</span>getElementText<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">[</span><span class="token string">'key123'</span><span class="token punctuation">,</span><span class="token string">'value'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 元素value属性值获取，缓存key键为“key123”</span>

<span class="token comment"># 实例五</span>
keyword<span class="token punctuation">.</span>getElementText<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">[</span><span class="token string">'value'</span><span class="token punctuation">,</span> <span class="token string">'int'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 元素value属性值中的阿拉伯数字获取，缓存key键默认</span>

<span class="token comment"># 实例六</span>
keyword<span class="token punctuation">.</span>getElementText<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">[</span><span class="token string">'value'</span><span class="token punctuation">,</span> <span class="token string">'key345'</span><span class="token punctuation">,</span> <span class="token string">'date'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 元素value属性值中的日期数据获取，缓存key键为“key345”</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字主要用于获取指定元素的数据值，并将该值存放到缓存中，以供其它关键字或者方法读取使用。</li>
<li>content形参(在用例步骤中为 “操作值” 单元格中书写的值)代表要获取元素值的操作依据，可接收三种类型的数据 “空 / string / list”。
<ul>
<li>当参数值为空(None)时：代表要对元素的text文本值进行随机保存；随机保存时的key键为“key_当前时间戳”；</li>
<li>当参数值为string类型时：关键字可以接收三种操作值中的任意一个 <code>key键</code>、<code>attribute何种属性</code>、<code>condition筛选出何种类型的数据</code>，并根据传入的操作值对目标元素进行处理；</li>
<li>当参数值为list类型时：可以同时接收三种操作值 [‘<code>key键</code>’, ‘<code>attribute何种属性</code>’, ‘<code>condition筛选出何种类型的数据</code>’]进行处理，并根据传入的操作值对目标元素进行处理。</li>
</ul>
</li>
<li>关键字中支持5种数据类型的筛选，分别为<code>int 整型</code>、 <code>text 文本字符串</code>、<code>date 日期</code> 、<code>time 时间</code>、<code>dateTime 日期时间</code>。</li>
<li>不管content形参(在用例步骤中为 “操作值” 单元格中书写的值)为何种参数形式，只要是出现“未指定key键”的情况，关键字则默认以“key_当前时间戳”为key键将获取到的值存入到缓存中。</li>
<li>不管content形参(在用例步骤中为 “操作值” 单元格中书写的值)为何种参数形式，只要是出现“未指定attribute属性值”的情况，关键字则默认获取元素的“text文本值”。</li>
</ul>
<p><strong>关键字使用规则解释</strong></p>
<ul>
<li>当content形参为list类型时，其中各项不需要按照特定顺序可随意书写，关键字会自动进行判别筛选; 例如<code>[key, attribute, condition]</code> || <code>[attribute, condition , key]</code>。</li>
<li>如果出现 “指定属性名不存在”的情况，则该“不存在”的属性名将视情况而定自动转为key键。
<ul>
<li>关键字未指定key键: 例如’value(属性不存在)'则key键名为：value</li>
<li>关键字已指定key键: 例如 [‘key_One(这里表示key键)’, ‘value(属性不存在)’] 则key键名为：key_Onevalue</li>
</ul>
</li>
<li>如果出现“获取属性重复”的情况，则“权重低”的属性名将视情况而定自动转为key键。
<ul>
<li>关键字未指定key键: 例如 [‘value’(判定为属性),‘onclick’(判定为key键)]</li>
<li>关键字已指定key键: 例如 [‘key_One(这里表示key键)’, ‘value(表示属性，判定为属性)’, ‘onclick(表示属性，判定为key键)’] 则key键名为：key_Oneonclick</li>
</ul>
</li>
<li>如果出现 “<code>key键</code>” 与 “<code>attribute何种属性</code>”同名情况时，权重最高的值判定为属性，顺位为key键；例如[‘value’(判定为属性),‘value’(判定为key键)]。</li>
<li>如果出现“关键字筛选结果不唯一”的情况，则筛选结果列表中的第一项为筛选的最终结果。
<ul>
<li>12VALUE14: 使用“<code>int</code>”筛选标识，将目标数据中的所有“整型数字”筛选出来的结果为 “12”</li>
<li>汉123字: 使用“<code>text</code>”筛选标识，将目标数据中所有“汉字文本”筛选出来的结果为 “汉”</li>
</ul>
</li>
</ul>
<blockquote>
<p><strong>特殊名词解释：</strong><br>
<code>content形参</code>：在用例步骤中为 “操作值” 单元格中书写的值，在脚本中为关键字名为“content”的形参<br>
<code>key</code>：代表缓存和取出缓存时的key键<br>
<code>attribute</code>：代表要获取元素的那个属性<br>
<code>condition</code>：代表要对获取数据进行何种类型的筛选</p>
</blockquote>
<hr>
<h4><a id="takeElementText__2654"></a>takeElementText() 关键字</h4>
<blockquote>
<p>取出缓存中的元素数据值，并以该值为依据对某个结果做断言判断</p>
</blockquote>
<p><strong>描述</strong><br>
取出缓存中通过“<code>getElementText 关键字</code>”缓存的元素数据值，并以该值为依据对页面中某些元素的指定值做遍历断言，若条件成立则返回<code>True</code>不成立则返回<code>False</code>，关键字的默认断言逻辑为 “当预期结果与实际结果一致时条件不成立，当预期结果与实际结果不一致时条件成立”</p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>复数定位方式, 定位表达式</td>
<td>[[‘key键名’][,‘属性名’][,‘是否取反’]] / key键名 / 属性名 / 逻辑取反 / 空</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>takeElementText</td>
<td>key1/key2</td>
<td align="left">[[‘key键名’][,‘属性名’][,‘是否取反’]] / key键名 / 属性名 / 逻辑取反 / 空</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>takeElementText</td>
<td>id/dis/xpaths…</td>
<td>对应表达式</td>
<td align="left">[[‘key键名’][,‘属性名’][,‘是否取反’]] / key键名 / 属性名 / 逻辑取反 / 空</td>
</tr>
</tbody>
</table><p><strong>元素节点数据区分 elementData.yaml文件书写示例</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># 区分元素节点数据 - “元素定位信息”elementData.yaml文件书写示例</span>
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span>  ids <span class="token punctuation">|</span><span class="token punctuation">|</span> xpaths <span class="token punctuation">|</span><span class="token punctuation">|</span> css_selectors …   <span class="token comment"># 框架中支持即可，仅允许使用复数定位方式</span>
    <span class="token punctuation">-</span> 对应方式的定位表达式
</code></pre>
<p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>takeElementText<span class="token punctuation">(</span><span class="token string">'复数定位方式'</span><span class="token punctuation">,</span><span class="token string">'定位表达式'</span><span class="token punctuation">[</span><span class="token punctuation">,</span>content<span class="token operator">=</span><span class="token string">'操作依据'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 元素数据值缓存</span>

<span class="token triple-quoted-string string">'''
def takeElementText(self, targeting, element, content=None) 注意关键字在定义时的参数顺序
@ targeting: 定位方式
@ element: 定位表达式
@ content: 操作依据

注意：根据python的函数传参规则，若要按照顺序传参的方式调用关键字，则需要严格按照关键字在定义时的参数位置顺序进行参数值书写，若不按照顺序传参的方式调用关键字，则需要在调用时标明参数值的形参名称如 ‘targeting=xx’ ‘element=xx’ ‘index=xx’等等。
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>takeElementText<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">)</span>  <span class="token comment"># 取出“最近一次”缓存的元素数据值，对界面中指定元素的txt文本值做遍历检查，验证是否均不等于缓存数据</span>

<span class="token comment"># 实例二</span>
keyword<span class="token punctuation">.</span>takeElementText<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token string">'value'</span><span class="token punctuation">)</span>  <span class="token comment"># 取出“最近一次”缓存的元素数据值，对界面中指定元素的value属性值做遍历检查，验证是否均不等于缓存数据</span>

<span class="token comment"># 实例三</span>
keyword<span class="token punctuation">.</span>takeElementText<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token string">'key123'</span><span class="token punctuation">)</span>  <span class="token comment"># 取出缓存数据中“key123”键对应的元素数据值，对界面中指定元素的txt文本值做遍历检查，验证是否均不等于缓存数据</span>

<span class="token comment"># 实例四</span>
keyword<span class="token punctuation">.</span>takeElementText<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">[</span><span class="token string">'key123'</span><span class="token punctuation">,</span><span class="token string">'value'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 取出缓存数据中“key123”键对应的元素数据值，对界面中指定元素的value属性值做遍历检查，验证是否均不等于缓存数据</span>

<span class="token comment"># 实例五</span>
keyword<span class="token punctuation">.</span>takeElementText<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">[</span><span class="token string">'value'</span><span class="token punctuation">,</span> <span class="token boolean">True</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 取出“最近一次”缓存的元素数据值，对界面中指定元素的text文本值做遍历检查，验证是否均与缓存数据一致</span>

<span class="token comment"># 实例六</span>
keyword<span class="token punctuation">.</span>takeElementText<span class="token punctuation">(</span><span class="token string">'ids'</span><span class="token punctuation">,</span> <span class="token string">'kw'</span><span class="token punctuation">,</span> index<span class="token operator">=</span><span class="token number">0</span><span class="token punctuation">,</span> content<span class="token operator">=</span><span class="token punctuation">[</span><span class="token string">'value'</span><span class="token punctuation">,</span> <span class="token string">'key345'</span><span class="token punctuation">,</span> <span class="token boolean">True</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 取出缓存数据中“key345”键对应的元素数据值，对界面中指定元素的value属性值做遍历检查，验证是否均与缓存数据一致</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字主要用于取出通过<code>getElementText 关键字</code>缓存的元素数据，并对指定元素的指定值进行遍历检查。</li>
<li>在使用关键字时所传入的元素定位信息应为“复数定位”(定位方式末尾带有‘s’时为复数定位)且不允许使用索引值，若传入“单元素定位”会使关键字无法做出正确的判断。</li>
<li>content形参(在用例步骤中为 “操作值” 单元格中书写的值)代表要断言的依据，可接收三种类型的数据 “空 / string / list”。
<ul>
<li>当参数值为空(None)时：代表“指定元素的text文本值”要与“缓存数据中最后一个key键对应的value值”进行比对判断；</li>
<li>当参数值为(string)时：关键字可以接收三种操作值中的任意一个 <code>key键</code>、<code>attribute何种属性</code>、<code>reversal是否需要逻辑取反</code>进行处理；</li>
<li>当参数值为(list)时：可以同时接收三种操作值 [“<code>key键</code>”, “<code>attribute何种属性</code>”, “<code>reversal是否需要逻辑取反</code>”]进行处理。</li>
</ul>
</li>
<li>逻辑取反(传入True代表取反，关键字默认为False)：当“取反状态”时 A!=B抛出错误，当“非取反状态(默认状态)”时 A==B抛出错误。</li>
<li>不管content形参(在用例步骤中为 “操作值” 单元格中书写的值)为何种参数形式，只要是出现“未指定key键”的情况，关键字则默认将缓存数据中最后一个key键对应的value值取出作为断言判断依据。</li>
<li>不管content形参(在用例步骤中为 “操作值” 单元格中书写的值)为何种参数形式，只要是出现“未指定attribute属性值”的情况，关键字则默认获取元素的“text文本值”。</li>
</ul>
<p><strong>关键字使用规则解释</strong></p>
<ul>
<li>“要进行比较的元素”必须是一个元素列表，定位方式必须是复数定位形式。</li>
<li>当content形参为list类型时，其中各项可随意书写不需要按照特定顺序书写，关键字会自动进行判别筛选。例如 <code>['value','key_one',True]</code> || <code>[True,'key_one','value']</code>。</li>
<li>当content形参为list类型时，子项个数需要在 2 - 3 个范围内否则无实际意义。例如 <code>['value','key_one']</code> || <code>['value', True]</code> || <code>[True,'key_one','value']</code>。</li>
<li>如果出现 “<code>key键</code>” 与 “<code>attribute何种属性</code>”同名情况时，权重最高的值判定为key键顺位为属性值，例如 <code>['value'(判定为key),'value'(判定为属性值)]</code>。</li>
<li>如果出现 “重复key键”的情况，则权重最高的判定为key键顺位为属性值，例如 <code>['key_One'(判定为key),'key_Two'(判定为属性值)]</code>。</li>
<li><font color="red">[非法]</font> 如果出现 “重复属性”的情况，则对给出的所有属性做字符串拼接后判定为属性值，例如 <code>['value','onclick']</code>，处理结果为 <code>['valueonclick'(判定为属性值)]</code>。</li>
</ul>
<blockquote>
<p><strong>特殊名词解释：</strong><br>
<code>content形参</code>：在用例步骤中为 “操作值” 单元格中书写的值，在脚本中为关键字名为“content”的形参<br>
<code>key</code>：代表要取出数据所对应的key键<br>
<code>attribute</code>：代表要对指定元素的那个属性做比较<br>
<code>reversal</code>：代表是否将关键字的断言逻辑“取反”(从默认的“A!=B”条件成立，修改为取反后的“A==B”条件成立)</p>
</blockquote>
<hr>
<h3><a id="_2743"></a>特殊功能</h3>
<h4><a id="Interface_Invoke__2744"></a>Interface_Invoke() 关键字</h4>
<blockquote>
<p>根据指定的接口数据文件路径，找到并执行文件中的接口数据</p>
</blockquote>
<p><strong>描述</strong><br>
根据传入的接口数据文件路径，找到并将文件中的数据逐条读出，根据数据中的接口信息在逐条进行后台接口请求</p>
<blockquote>
<p>接口数据文件：用来存放接口请求信息的数据文件，固定为：InterfaceData.yaml</p>
<blockquote>
<p>接口请求由框架中‘接口处理模块’完成并非关键字自身的逻辑，你也可以理解为<code>Interface_Invoke()</code>关键字就是框架中‘接口处理模块’的入口函数</p>
</blockquote>
</blockquote>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>无参</td>
<td>接口数据文件路径</td>
</tr>
</tbody>
</table><p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>Interface_Invoke</td>
<td></td>
<td>C:\xxx\xxx\xxx</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>Interface_Invoke</td>
<td></td>
<td></td>
<td>C:\xxx\xxx\xxx</td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
<span class="token keyword">try</span><span class="token punctuation">:</span>
	keyword<span class="token punctuation">.</span>Interface_Invoke<span class="token punctuation">(</span><span class="token string">r'c:\xxx\xx\xx'</span><span class="token punctuation">)</span>  <span class="token comment"># 接口数据执行</span>
<span class="token keyword">except</span> Exception <span class="token keyword">as</span> error<span class="token punctuation">:</span>
	<span class="token keyword">print</span><span class="token punctuation">(</span><span class="token string-interpolation"><span class="token string">f"接口执行失败，捕获异常：</span><span class="token interpolation"><span class="token punctuation">{</span>error<span class="token punctuation">}</span></span><span class="token string">"</span></span><span class="token punctuation">)</span>
<span class="token keyword">else</span><span class="token punctuation">:</span>
	<span class="token keyword">pass</span>  <span class="token comment"># 接口执行成功</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>关键字主要用于弥补框架在用例文件中不可调用接口执行的不足，你可以通过调用该关键字执行任意一组合法的接口数据，而不需要像与用例步骤文件配套的接口数据一样需要注意与用例步骤文件的文件夹层级关系。</li>
<li>关键字所使用的接口数据与“用例配套的接口数据”语法和格式均一致，本身没有任何逻辑操作，它主要是靠调用框架中的接口处理模块来完成与接口相关的操作，故它不需要给“元素定位信息”单元格赋值。</li>
<li>在脚本中调用该关键字时需注意关键字本身没有返回值，若接口执行失败(执行异常、执行结果断言未通过)则会触发异常。</li>
</ul>
<hr>
<h4><a id="ternary_Judgement__2784"></a>ternary_Judgement() 关键字</h4>
 <a id="ternary_Judgement">
</a><blockquote>
<p>三元判断，控制用例步骤执行</p>
</blockquote>
<p><strong>描述</strong><br>
三元判断，支持对指定元素的属性、文本值以及单独的条件表达式进行处理，已达到控制用例步骤执行的目的</p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>[定位方式, 定位表达式][, 索引位置]</td>
<td>[条件list / string, 控制行数int]</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>参数说明</strong></p>
<ul>
<li>content形参(在用例步骤中为 “操作值” 单元格中书写的值) <code>list</code>类型；列表第一项为判断条件，第二项为关键字控制行数。
<ul>
<li>判断条件：可接受两种类型参数 <code>list</code>类型、<code>string</code>类型
<ul>
<li>list：在对元素的属性、文本值做判断时传入该类型； <code>[[属性名,]关系运算符,预期值]</code>，属性名可省略</li>
<li>string：表示单独条件表达式；例如 A==B、C&gt;=D</li>
</ul>
</li>
<li>控制行数：<code>int</code>类型；代表在关键字条件成立的情况下所控制的步骤行数</li>
</ul>
</li>
</ul>
<pre><code class="prism language-python"><span class="token comment"># 传值示例一：</span>
<span class="token punctuation">[</span><span class="token punctuation">[</span><span class="token string">'value'</span><span class="token punctuation">,</span><span class="token string">'&gt;='</span><span class="token punctuation">,</span><span class="token string">'25'</span><span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token number">2</span><span class="token punctuation">]</span>  <span class="token comment"># 对指定元素的value属性值做判断，验证其是否大于等于25，若成立则当前行下的两行将不再执行</span>

<span class="token comment"># 传值示例二：</span>
<span class="token punctuation">[</span><span class="token punctuation">[</span><span class="token string">'=='</span><span class="token punctuation">,</span><span class="token string">'测试文本'</span><span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token number">3</span><span class="token punctuation">]</span>  <span class="token comment"># 对指定元素的文本值做判断，验证其是否等于“测试文本”，若成立则当前行下的三行将不再执行</span>

<span class="token comment"># 传值示例三：</span>
<span class="token punctuation">[</span><span class="token punctuation">[</span><span class="token string">'in'</span><span class="token punctuation">,</span><span class="token string">'测试'</span><span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token number">3</span><span class="token punctuation">]</span>  <span class="token comment"># 对指定元素的文本值做判断，验证其是否包含“测试”二字，若成立则当前行下的三行将不再执行</span>

<span class="token comment"># 传值示例四：</span>
<span class="token punctuation">[</span><span class="token punctuation">[</span><span class="token string">'not in'</span><span class="token punctuation">,</span><span class="token string">'文本'</span><span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token number">3</span><span class="token punctuation">]</span>  <span class="token comment"># 对指定元素的文本值做判断，验证其是否不包含“文本”二字，若成立则当前行下的三行将不再执行</span>

<span class="token comment"># 传值示例五：</span>
<span class="token punctuation">[</span><span class="token string">"1 &gt;= 0"</span><span class="token punctuation">,</span> <span class="token number">1</span><span class="token punctuation">]</span>  <span class="token comment"># 验证表达式“1 &gt;= 0”是否成立，若成立则当前行下的一行将不再执行</span>

<span class="token comment"># 传值示例六：</span>
<span class="token punctuation">[</span><span class="token string">"1 or 0"</span><span class="token punctuation">,</span> <span class="token number">4</span><span class="token punctuation">]</span>  <span class="token comment"># 验证表达式“1 or 0”是否成立，若成立则当前行下的四行将不再执行</span>
</code></pre>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>ternary_Judgement</td>
<td>key1/key2</td>
<td>[条件, 控制行数]</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th>操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>ternary_Judgement</td>
<td>id/dis/xpaths…</td>
<td>对应表达式</td>
<td>[条件, 控制行数]</td>
</tr>
</tbody>
</table><p><strong>元素节点数据区分 elementData.yaml文件书写示例</strong></p>
<pre><code class="prism language-yaml"><span class="token comment"># 区分元素节点数据 - “元素定位信息”elementData.yaml文件书写示例</span>
<span class="token key atrule">key1</span><span class="token punctuation">:</span>
  <span class="token key atrule">key2</span><span class="token punctuation">:</span>
    <span class="token punctuation">-</span>  ids <span class="token punctuation">|</span><span class="token punctuation">|</span> xpaths <span class="token punctuation">|</span><span class="token punctuation">|</span> css_selectors …   <span class="token comment"># 框架中支持即可，仅允许使用复数定位方式</span>
    <span class="token punctuation">-</span> 对应方式的定位表达式
</code></pre>
<p><strong>脚本使用示例</strong></p>
<blockquote>
<p><font color="red">关键字不支持在脚本中使用</font></p>
</blockquote>
<p><strong>注意事项</strong></p>
<ul>
<li>不论判断条件采用何种形式书写，若条件成立则关键字所控制的用例步骤行将不再执行。</li>
<li>不论判断条件采用何种形式书写，若条件不成立则关键字作废，所控制的用例步骤行自动释放执行。</li>
<li>不论判断条件采用何种形式书写，可选用的关系运算符为 ==、&gt;=、&lt;=、!=、&gt;、&lt;、not in、in，其它的关系运算符无法识别(<code>not in</code>，运算符中间需要用空格分开)。</li>
<li>关键字所控制的单元行从当前行向下覆盖，不包括当前行，例如 “当前行为3，若控制行数为2，则控制 4、5两行”。</li>
<li>在判断条件采用 “单独条件表达式 <code>string</code>” 形式时，支持在表达式中使用逻辑运算符 and、or、not。</li>
<li>在判断条件采用 “单独条件表达式 <code>string</code>” 形式时，与元素定位相关的数据无论书写与否均不会生效。</li>
<li>在判断条件采用 “元素判断 <code>list</code>” 形式时，元素定位参数为必填项，为空则关键字无法正常执行。</li>
<li>在判断条件采用 “元素判断 <code>list</code>” 形式时，元素属性值若省略则代表对元素的text文本值做判断。</li>
<li>在判断条件采用“元素判断  <code>list</code>”形式时，若所指定的 “属性名” 在元素中不存在，则将其直接拼接在“预期结果”中。</li>
<li>在判断条件采用“元素判断  <code>list</code>”形式时，若所指定的 “关系运算符” 不合法，则将其直接拼接在“预期结果”中。</li>
<li>在判断条件采用“元素判断  <code>list</code>”形式时，关键字的条件判断依据为 “实际结果”；例如 “实际结果 &gt;= 预期结果”、“实际结果 包含 预期结果”。</li>
</ul>
<hr>
<h4><a id="winUpload__2859"></a>winUpload() 关键字</h4>
<blockquote>
<p>文件批量上传</p>
</blockquote>
<p><strong>描述</strong><br>
处理页面非<code>&lt;input type="file"&gt;</code>标签(窗口批量上传)的文件上传，支持同一目录、不同目录下的多文件上传；目前只针对windows操作系统</p>
<p><strong>参数</strong></p>

<table>
<thead>
<tr>
<th>元素定位参数</th>
<th>操作参数</th>
</tr>
</thead>
<tbody>
<tr>
<td>无</td>
<td>[‘文件路径1’[,‘文件路径2’][,‘文件路径n’…]]</td>
</tr>
</tbody>
</table><blockquote>
<p><em>[, xxx]  代表可省略</em></p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>winUpload</td>
<td></td>
<td align="left">[‘文件路径1’[,‘文件路径2’][,‘文件路径n’…]]</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>winUpload</td>
<td></td>
<td></td>
<td align="left">[‘文件路径1’[,‘文件路径2’][,‘文件路径n’…]]</td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<pre><code class="prism language-python"><span class="token comment"># 导入框架</span>
<span class="token keyword">import</span> kdtest
keyword <span class="token operator">=</span> kdtest<span class="token punctuation">.</span>GSTORE<span class="token punctuation">[</span><span class="token string">'keyword'</span><span class="token punctuation">]</span>  <span class="token comment"># 取出关键字对象</span>
keyword<span class="token punctuation">.</span>winUpload<span class="token punctuation">(</span><span class="token punctuation">[</span><span class="token string">'文件路径1'</span><span class="token punctuation">[</span><span class="token punctuation">,</span><span class="token string">'文件路径2'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token punctuation">,</span><span class="token string">'文件路径n'</span>…<span class="token punctuation">]</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 文件批量上传</span>

<span class="token triple-quoted-string string">'''
def winUpload(self, filePath) 注意关键字在定义时的参数顺序
@ filePath: 要上传的文件的绝对路径列表
'''</span>
<span class="token comment"># 实例一</span>
keyword<span class="token punctuation">.</span>winUpload<span class="token punctuation">(</span><span class="token punctuation">[</span><span class="token string">'c:/xx/xx/xx.xx'</span><span class="token punctuation">,</span><span class="token string">'c:/xx/xx/xx.xx'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 文件批量上传</span>

<span class="token comment"># 实例二</span>
keyword<span class="token punctuation">.</span>winUpload<span class="token punctuation">(</span>filePath<span class="token operator">=</span><span class="token punctuation">[</span><span class="token string">'c:/xx/xx/xx.xx'</span><span class="token punctuation">,</span><span class="token string">'c:/xx/xx/xx.xx'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># 文件批量上传</span>
</code></pre>
<p><strong>注意事项</strong></p>
<ul>
<li>content形参(在用例步骤中为 “操作值” 单元格中书写的值)应为list类型代表要上传的文件路径列表，路径应采用绝对路径形式。</li>
<li>传值示例：<code>['c:\xxx\xxx\xxx\xxx.txt','c:\xxx\xxx\xxx\xxx.jpeg']</code></li>
</ul>
<hr>
<h2><a id="_plugins_2902"></a>三、框架自定义插件方法 (plugins)</h2>
<p>此类方法需要使用者根据实际的被测系统自行开发，框架中不提供。</p>
<p><strong>使用规则</strong><br>
<code>[插件名]方法名</code></p>
<p><strong>参数</strong><br>
视实际而定</p>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[插件名]方法名</td>
<td></td>
<td align="left">参数</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[插件名]方法名</td>
<td></td>
<td></td>
<td align="left">参数</td>
</tr>
</tbody>
</table><p><strong>脚本使用示例</strong></p>
<blockquote>
<p><font color="red"> 自定义插件方法不支持在脚本中使用</font></p>
</blockquote>
<p><strong>注意事项</strong></p>
<ul>
<li>插件方法不支持在脚本中使用。</li>
<li>插件方法不支持通过用例步骤传递“元素定位数据”</li>
<li>插件方法在使用时需要严格按照 <code>[插件名]方法名</code>的格式使用。</li>
<li>插件名区分大小写且与方法名之间不允许出现空格</li>
<li>插件方法支持两种形式的参数传递方式，分别为：“list(顺序传递)” 和 “dict(指定参数)”，若无需参数时为空即可。</li>
</ul>
<hr>
<h1><a id="OA_WebUI_2930"></a>OA_WebUI插件方法说明</h1>
<p>只针对TDOA Web端做操作如“人员选择”、“日期选择”、“模块跳转”等等，该插件中的方法只在内部使用，目的则是为了方便对OA系统书写测试用例，正式发布的框架中不存在该插件。</p>
<blockquote>
<p>注意：OA_WebUI插件中的所有方法均不支持在脚本中使用</p>
</blockquote>
<h3><a id="1userLogin_2933"></a>1、userLogin()</h3>
<blockquote>
<p>用户登录</p>
</blockquote>
<p><strong>描述</strong><br>
针对OA系统web端的登录页面做操作</p>
<p><strong>参数</strong><br>
@param <strong>userName</strong> <code>string类型</code>：用户名<br>
@param <strong>userPassword</strong> <code>string类型</code>：密码</p>
<blockquote>
<p>userName 和 userPassword 两参数均可省略</p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[OA_webUI]userLogin</td>
<td></td>
<td align="left">{‘userName’:‘admin’,‘userPassword’:‘123’}</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[OA_webUI]userLogin</td>
<td></td>
<td></td>
<td align="left">{‘userName’:‘admin’,‘userPassword’:‘123’}</td>
</tr>
</tbody>
</table><p><strong>注意事项</strong></p>
<ul>
<li>方法中的 <strong>userName</strong> 和 <strong>userPassword</strong> 参数所接收的值类型均为 string类型。</li>
<li>支持两种参数传递方式分别为：<code>{'userName':'xxx','userPassword':'xxx'}</code> 、<code>['xxx','xxx']</code>。</li>
</ul>
<hr>
<h3><a id="2jumpFrame_2957"></a>2、jumpFrame()</h3>
<blockquote>
<p>iframe焦点一次性多级跳转</p>
</blockquote>
<p><strong>描述</strong><br>
对页面中的iframe焦点进行一次性的多级跳转</p>
<p><strong>参数</strong><br>
@param <strong>Hierarchy</strong> <code>list类型</code>：代表要跳转的frame的层级，以及对应层级的节点</p>
<p><strong>参数说明</strong></p>
<ul>
<li>Hierarchy参数书写规则  [n, [iframe节点,…]]:
<ul>
<li>n： 要进行跳转的层级个数，大于等于0</li>
<li>[iframe节点,…]： 要进行跳转的iframe节点列表，个数要与“N进行跳转的层级个数”一致，单个节点可以是“标签id属性值”、“标签页面索引”、“标签src属性值”其中的任意一个</li>
</ul>
</li>
<li>Hierarchy参数合法书写示例：<code>[3, ['iframe1',0,'/portal/home/']]</code>  或者  <code>[2, ['iframe1','/portal/home/']] </code></li>
</ul>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[OA_webUI]jumpFrame</td>
<td></td>
<td align="left">{‘Hierarchy’:[n,[xxx,xxx…]]}</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[OA_webUI]jumpFrame</td>
<td></td>
<td></td>
<td align="left">{‘Hierarchy’:[n,[xxx,xxx…]]}</td>
</tr>
</tbody>
</table><p><strong>注意事项</strong></p>
<ul>
<li>方法是对OA系统中“多层级iframe标签嵌套”的解决方案，用于一次性的多层级iframe焦点跳转。</li>
<li>方法支持两种传值方式分别为 “<code>[xx,xx...]列表顺序传参</code>”、“<code>{'参数名':'参数值'...}字典指定参数传参</code>”，你可以根据实际情况书写。</li>
<li>方法中的可以处理三种类型的“iframe节点”分别为 “标签id属性值”、“标签页面索引”、“标签src属性值”。</li>
<li>方法不做正确性判断，注意传入的层级节点的对应关系是否正确。</li>
</ul>
<hr>
<h3><a id="3errorHandle_2987"></a>3、errorHandle()</h3>
<blockquote>
<p>OA系统“强制”错误提示处理</p>
</blockquote>
<p><strong>描述</strong><br>
对OA系统中的 “alert弹框”、“系统信息提示框”、“右上角消息弹框”进行识别和处理，提示处理优先级为 alert弹框 &gt; 系统信息提示框 &gt; 右上角消息弹框</p>
<p><strong>参数</strong><br>
@param <strong>type</strong> <code>布尔类型</code>：<code>True</code>代表点击alert弹框的【确定】按钮，<code>False</code>代表点击alert弹框的【取消】按钮，若省略则为<code>False</code><br>
@param <strong>prompt_input</strong> <code>string类型</code>：代表在alert - prompt类型弹框时要输入的文本内容</p>
<blockquote>
<p>type 和 prompt_input 两参数均可省略</p>
</blockquote>
<p><strong>参数说明</strong></p>
<ul>
<li>不传参：一个单按钮的alert弹框(不管按钮是【确认】还是【取消】)，或者一个系统提示信息(不管是否存在按钮)，或者右上角的一个消息弹框，你可以直接调用该插件方法而不需要传任何值；</li>
<li>type传参：一个双按钮的alert提示框，传入<code>True</code>就代表以点击【确认】按钮来处理这个alert弹框。若不传值或者传入<code>False</code>就代表以点击【取消】按钮来处理这个alert弹框；</li>
<li>prompt_input传参：一个alert - prompt类型弹框需要你输入一个值之后才可处理，prompt_input就代表你要输入的值，若是此时type为空则代表点击prompt弹框的【取消】按钮；</li>
<li>type、prompt_input同时传参：一个alert - prompt类型弹框需要你输入一个值之后在点击【确认】按钮，此时prompt_input传入你要输入的值，type传入True；</li>
</ul>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[OA_webUI]errorHandle</td>
<td></td>
<td align="left">{‘type’:True,‘prompt_input’:‘要输入的内容’}</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[OA_webUI]errorHandle</td>
<td></td>
<td></td>
<td align="left">{‘type’:True,‘prompt_input’:‘要输入的内容’}</td>
</tr>
</tbody>
</table><p><strong>注意事项</strong></p>
<ul>
<li>方法处理的优先级为 alert弹框 &gt; 系统信息提示框 &gt; 右上角消息弹框。</li>
<li>插件方法会自动识别当前页面中的“alert弹框”、“系统信息提示框”、“右上角消息提示框”，如果在同时出现则优先处理权重较高的。</li>
<li>插件方法支持两种传值方式分别为 “[xx,xx…]列表顺序传参”、“{‘参数名’:‘参数值’…}字典指定参数传参”，你可以根据实际情况书写。</li>
<li>方法的处理取决于实际的页面场景，并不是你传入<code>type=True</code>就会点击alert的【确定】按钮，也不是你传入<code>prompt_input=“xxx”</code>就会在prompt弹框中输入值。故方法需要你结合实际的页面表现使用。</li>
</ul>
<hr>
<h3><a id="4WeakHint_3019"></a>4、WeakHint()</h3>
<blockquote>
<p>OA系统“文本弱提示”处理</p>
</blockquote>
<p><strong>描述</strong><br>
用于处理一些OA系统中的弱提示弹框；方法存在返回值，返回值为<code>string</code>类型，是当前页面中所有弱提示文本的字符串拼接</p>
<blockquote>
<p><img src="https://img-blog.csdnimg.cn/5de79545ca5a49c9847d4cf7af3ca175.png" alt="在这里插入图片描述"></p>
</blockquote>
<p><strong>参数</strong><br>
无参</p>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[OA_webUI]WeakHint</td>
<td></td>
<td align="left"></td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[OA_webUI]WeakHint</td>
<td></td>
<td></td>
<td align="left"></td>
</tr>
</tbody>
</table><p><strong>注意事项</strong></p>
<ul>
<li>方法会自动识别当前页面中弹出的所有弱提示弹框，并获取它们的提示文本。</li>
<li>方法只获取它们的提示文本而并不会关闭它们。</li>
</ul>
<hr>
<h3><a id="5personnelChoice_3042"></a>5、personnelChoice()</h3>
<blockquote>
<p>OA系统“人员选择组件”操作</p>
</blockquote>
<p><strong>描述</strong><br>
根据传入的“待选人员信息”，对系统中的“人员选择组件”进行操作，完成人员选择</p>
<blockquote>
<p><img src="https://img-blog.csdnimg.cn/70914a8314dd43ffa5a554532665cf3c.png" alt="在这里插入图片描述"></p>
</blockquote>
<p><strong>参数</strong><br>
@param <strong>type</strong> <code>string类型</code>：人员选择方式标识<br>
@param <strong>dataList</strong> <code>list类型</code>：按“部门”、“角色”、“分组”方式选择时的人员信息<br>
@param <strong>name</strong> <code>string类型</code>：人员检索选择时的人员姓名<br>
@param <strong>department</strong> <code>string类型</code>：部门人员全选时的部门名称</p>
<blockquote>
<p>dataList、name 和 department 参数可省略</p>
</blockquote>
<p><strong>参数说明</strong></p>
<ul>
<li>type参数解释：
<ul>
<li>人员选择方式标识，参数合法值： <code>'0'</code>部门、<code>'1'</code>角色、<code>'2'</code>分组、<code>'3'</code>在线、<code>'4'</code>检索</li>
</ul>
</li>
<li>dataList参数解释：
<ul>
<li>按照部门选择输入参数为：<code>dataList=[部门名称，人员姓名]</code> 用来存放按照部门进行添加时的人员和部门信息</li>
<li>按照角色选择输入参数为：<code>dataList=[人员角色名称，人员姓名]</code> 用来存放按照角色进行添加时的人员和角色信息</li>
<li>按照分组选择输入参数为：<code>dataList=[分组名称，人员姓名]</code> 用来存放按照分组进行添加时的人员和分组信息</li>
<li>按照部门选择时，单纯的一级目录结构参数格式为：<code>dataList = [部门名称，人员姓名]</code>。</li>
<li>大于一级的目录结构参数格式为：<code>dataList = [num(目录层级2,3,4..n)，[父级目录名称，子级目录名称...n]，人员姓名]</code>； 例如: <code> dataList=[4,['市场营销部', '销售部', '北京销售部', '销售三组'],'温炳康']</code>。</li>
<li>dataList参数在使用时，需要根据添加方式将type的值填充为’0’、‘1’、‘2’。</li>
</ul>
</li>
<li>name参数解释：
<ul>
<li>用来存放按照“检索方式”进行人员选择时的人员姓名。</li>
<li>使用“检索方式”进行人员选择，若出现两个同名人员的情况，则默认选择检索结果列表中的第一个条人员记录。</li>
<li>name参数在使用时需要将type的值填充为’4’(检索方式添加)。</li>
</ul>
</li>
<li>department参数解释：
<ul>
<li>用于存放当需要将整个部门的人员全部添加时的目标部门名称。</li>
<li>department参数在使用时需要将type的值填充为’0’(部门方式添加)。</li>
</ul>
</li>
</ul>
<p><strong>方法使用场景示例</strong>：</p>
<ul>
<li>通过“部门方式”选择“综合管理部 - 行政部 - 张敏”：<code>{'type': '0', 'dataList': [2,['综合管理部', '行政部'],'张敏']}</code></li>
<li>通过“在线方式”选择在线列表中的第一条人员记录：<code>{'type': '3'}</code></li>
<li>通过“检索方式”选择“王德”：<code>{'type': '4', 'name': '王德'}</code></li>
<li>将综合管理部中的人员全部选中：<code>{'type': '0', 'department': '综合管理部'}</code></li>
</ul>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[OA_webUI]personnelChoice</td>
<td></td>
<td align="left">{‘type’:‘选人方式’[, ‘dataList’:操作值][,‘name’:‘检索人员姓名’][,‘department’:‘部门名称’]}</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[OA_webUI]personnelChoice</td>
<td></td>
<td></td>
<td align="left">{‘type’:‘选人方式’[, ‘dataList’:操作值][,‘name’:‘检索人员姓名’][,‘department’:‘部门名称’]}</td>
</tr>
</tbody>
</table><p><strong>注意事项</strong></p>
<ul>
<li>方法仅支持一种传值方式：“{‘参数名’:‘参数值’…}字典指定参数传参”。</li>
<li>方法在通过“<code>在线 type=3</code>”方式进行人员选择时，<code>dataList 参数</code>、<code>name 参数</code>、<code>department 参数</code>均不需要传值，方法将自动选择“人员在线列表”中的第一条人员记录。</li>
</ul>
<hr>
<h3><a id="6setDate_3093"></a>6、setDate()</h3>
<blockquote>
<p>OA系统“日期选择组件”操作</p>
</blockquote>
<p><strong>描述</strong><br>
根据传入的“日期参数”信息，对系统中的“日期选择组件”进行操作，完成日期选择</p>
<blockquote>
<p><img src="https://img-blog.csdnimg.cn/3c733a36d31e497084ea61254d09e4bb.png" alt="在这里插入图片描述"></p>
</blockquote>
<p><strong>参数</strong><br>
@param <strong>expectDate</strong> <code>string类型</code>：代表要进行选择的日期</p>
<p><strong>参数说明</strong></p>
<ul>
<li>注意传入的日期，数据格式应为“YYYY-MM-DD”(2021-09-24 或者 2021-9-24)，其它的日期格式方法无法识别。</li>
</ul>
<p><strong>方法使用场景示例</strong></p>
<ul>
<li>你可以直接输入一个日期让其选择：<code>['2021-9-24']</code>  ||  <code>{'expectDate': '2021-9-24'}</code></li>
<li>你可以与内置函数配置使用，让其选择当前系统日期+1：<code>['Increasing_date(System_date(%Y-%m-%d), 1)']</code>  ||  <code>{'expectDate': 'Increasing_date(System_date(%Y-%m-%d), 1)'}</code></li>
<li>你可以让其输入一个在测试过程中通过getElementText关键字获取到的日期(通过‘time’键名保存)：<code>['get_PrestoreData(time)'] </code> ||  <code>{'expectDate': 'get_PrestoreData(time)'}</code></li>
</ul>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[OA_webUI]setDate</td>
<td></td>
<td align="left">{‘expectDate’: ‘待选择日期’}</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[OA_webUI]setDate</td>
<td></td>
<td></td>
<td align="left">{‘expectDate’: ‘待选择日期’}</td>
</tr>
</tbody>
</table><p><strong>注意事项</strong></p>
<ul>
<li>方法目前只可以对日期进行选择不支持时间选择。</li>
<li>插件方法支持两种传值方式分别为 “[xx,xx…]列表顺序传参”、“{‘参数名’:‘参数值’…}字典指定参数传参”，你可以根据实际情况书写。</li>
<li>根据你传入的日期，关键字会与当前组件中默认的日期进行大小值比较，并控制组件进行日期的“前”“后”跳转。</li>
<li>若你传入的日期与当前组件中默认的日期一致，则方法会直接点击组件中的【今天】按钮。</li>
<li>插件方法在在操作结束后，会初始化当前页面的iframe焦点，在使用结束后要注意iframe的层级关系(在调用时不必考虑该问题)。</li>
</ul>
<hr>
<h3><a id="7TipsSpringFrame_3127"></a>7、TipsSpringFrame()</h3>
<blockquote>
<p>OA系统“右上角消息弹框”处理</p>
</blockquote>
<p><strong>描述</strong><br>
根据传入的“指定操作标识”，处理系统中右上角消息弹框</p>
<p><strong>参数</strong><br>
@param <strong>type</strong> <code>string类型</code>：代表要对消息弹框进行操作的标识</p>
<p><strong>参数说明</strong></p>
<ul>
<li>目前方法支持识别的操作标识固定为：<code>exit</code> 关闭消息弹框、<code> readAll</code> 已阅全部</li>
</ul>
<blockquote>
<p>操作标识区分大小写，在使用时注意检查是否正确</p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[OA_webUI]TipsSpringFrame</td>
<td></td>
<td align="left">{‘type’:‘exit’}</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[OA_webUI]TipsSpringFrame</td>
<td></td>
<td></td>
<td align="left">{‘type’:‘exit’}</td>
</tr>
</tbody>
</table><p><strong>注意事项</strong></p>
<ul>
<li>插件方法支持两种传值方式分别为 “[xx,xx…]列表顺序传参”、“{‘参数名’:‘参数值’…}字典指定参数传参”，你可以根据实际情况书写。</li>
<li>若页面中不存在消息提示框，则方法不会做任何操作。</li>
</ul>
<hr>
<h3><a id="8FormInput_3153"></a>8、FormInput()</h3>
<blockquote>
<p>OA系统“复杂表单”内容填写</p>
</blockquote>
<p><strong>描述</strong><br>
对指定表单中的组件(input输入框、textarea多行文本输入框、radio单选按钮…)进行操作</p>
<p><strong>参数</strong><br>
@param <strong>Parent</strong> <code>string类型</code>：指定表单节点的css定位表达式<br>
@param <strong>operationStep</strong><code>dict类型</code>：子项的key键名固定，对应的value值均为<code>list类型</code>，用来存放要操作的数据信息</p>
<p><strong>参数说明</strong></p>
<ul>
<li>Parent 参数解释：
<ul>
<li>目标表单的css定位表达式</li>
</ul>
</li>
<li>operationStep 参数key键名解释：
<ul>
<li>键名为<code>input</code>代表对<code>&lt;input type='text'&gt;</code>文本输入框做操作</li>
<li>键名为<code>pass</code>代表对<code>&lt;input type='pass'&gt;</code>密码输入框做操作</li>
<li>键名为<code>textarea</code>代表对<code>&lt;textarea&gt;&lt;/textarea&gt;</code>多行文本输入框做操作</li>
<li>键名为<code>checkbox</code>代表对<code>&lt;input type='checkbox'&gt;</code>复选按钮做操作</li>
<li>键名为<code>radio</code>代表对<code>&lt;input type='radio'&gt;</code>单选按钮做操作</li>
<li>键名为<code>select</code>代表对<code>&lt;select&gt;&lt;/select&gt;</code>下拉列表框做操作</li>
</ul>
</li>
<li>operationStep 参数value值解释：
<ul>
<li>除键名为 “<code>select</code>” 的子项外，其它各键对应的value值均支持两种书写方式，分别为：
<ul>
<li>“组件先后顺序操作”方式：[xx, xx, xx, xx …]</li>
<li>“指定组件操作”方式：[[Name, xx], [Name, xx], [] …]</li>
</ul>
</li>
<li>键名为 “<code>select</code>” 的子项，对应的value值仅支持一种书写方式，为：
<ul>
<li>“指定组件操作”方式：[[Name, xx], [Name, xx], [] …]</li>
</ul>
</li>
</ul>
</li>
<li>operationStep传值格式示例：<pre><code class="prism language-python"><span class="token punctuation">{</span>
   <span class="token string">'input'</span><span class="token punctuation">:</span> <span class="token punctuation">[</span>xx<span class="token punctuation">,</span> xx<span class="token punctuation">,</span> xx<span class="token punctuation">,</span> xx <span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">]</span>   <span class="token operator">|</span><span class="token operator">|</span>  <span class="token punctuation">[</span><span class="token punctuation">[</span>Name<span class="token punctuation">,</span> xx<span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token punctuation">[</span>Name<span class="token punctuation">,</span> xx<span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token punctuation">[</span><span class="token punctuation">]</span> <span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">]</span>    <span class="token comment"># 普通文本输入框</span>

   <span class="token string">'pass'</span><span class="token punctuation">:</span> <span class="token punctuation">[</span>xx<span class="token punctuation">,</span> xx<span class="token punctuation">,</span> xx<span class="token punctuation">,</span> xx <span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">]</span>   <span class="token operator">|</span><span class="token operator">|</span>  <span class="token punctuation">[</span><span class="token punctuation">[</span>Name<span class="token punctuation">,</span> xx<span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token punctuation">[</span>Name<span class="token punctuation">,</span> xx<span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token punctuation">[</span><span class="token punctuation">]</span> <span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">]</span>    <span class="token comment"># 密码文本输入框</span>

   <span class="token string">'textarea'</span><span class="token punctuation">:</span> <span class="token punctuation">[</span>xx<span class="token punctuation">,</span> xx<span class="token punctuation">,</span> xx<span class="token punctuation">,</span> xx <span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">]</span>   <span class="token operator">|</span><span class="token operator">|</span>  <span class="token punctuation">[</span><span class="token punctuation">[</span>Name<span class="token punctuation">,</span> xx<span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token punctuation">[</span>Name<span class="token punctuation">,</span> xx<span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token punctuation">[</span><span class="token punctuation">]</span> <span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">]</span>    <span class="token comment"># 多行文本输入框 </span>
        
   <span class="token string">'checkbox'</span><span class="token punctuation">:</span> <span class="token punctuation">[</span>xx<span class="token punctuation">,</span> xx<span class="token punctuation">,</span> xx<span class="token punctuation">,</span> xx <span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">]</span>   <span class="token operator">|</span><span class="token operator">|</span>  <span class="token punctuation">[</span><span class="token punctuation">[</span>Name<span class="token punctuation">,</span> xx<span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token punctuation">[</span>Name<span class="token punctuation">,</span> xx<span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token punctuation">[</span><span class="token punctuation">]</span> <span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">]</span>    <span class="token comment"># 复选框选择  </span>

   <span class="token string">'radio'</span><span class="token punctuation">:</span> <span class="token punctuation">[</span>xx<span class="token punctuation">,</span> xx<span class="token punctuation">,</span> xx<span class="token punctuation">,</span> xx <span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">]</span>   <span class="token operator">|</span><span class="token operator">|</span>  <span class="token punctuation">[</span><span class="token punctuation">[</span>Name<span class="token punctuation">,</span> xx<span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token punctuation">[</span>Name<span class="token punctuation">,</span> xx<span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token punctuation">[</span><span class="token punctuation">]</span> <span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">]</span>    <span class="token comment"># 单选框选择</span>

   <span class="token string">'select'</span><span class="token punctuation">:</span> <span class="token punctuation">[</span><span class="token punctuation">[</span>Name<span class="token punctuation">,</span> xx<span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token punctuation">[</span>Name<span class="token punctuation">,</span> xx<span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token punctuation">[</span><span class="token punctuation">]</span> <span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">]</span>    <span class="token comment"># 下拉列表框</span>
<span class="token punctuation">}</span>
</code></pre>
</li>
<li>operationStep传值格式示例说明：
<ul>
<li>“ xx ”为实际的操作值 (目前方法支持操作的表单组件)：
<ul>
<li>在<code>input输入框</code>、<code>pass密码输入框</code>、<code>textarea多行文本输入框</code>中该值应为文本类型；</li>
<li>在<code>checkbox复选按钮</code>、<code>radio单选按钮</code>中该值为布尔类型 (True代表选中该按钮，False代表不选中)；</li>
<li>在<code>select下拉列表框</code>中该值可以是其列表子项的 “index索引值”、“value属性值” 和 “text文本值” (方法自动识别传入的值类型，不需要特殊标明)；</li>
</ul>
</li>
<li>传值方法分为两种，一种为 “<code>[xx, xx, xx, xx ..]</code> 按照组件先后顺序操作”，另一种为 “<code>[[Name, xx], [Name, xx], [] ..] </code> 指定组件操作”。
<ul>
<li>“按照组件先后顺序操作”：是按照对应表单组件在界面中的先后顺序进行操作，在使用时需要注意值输入顺序；</li>
<li>“指定组件操作”：是按照传入的组件Name属性值对指定组件进行定位并操作，该方法不需要考虑顺序问题；</li>
</ul>
</li>
<li>在使用 “按照组件先后顺序操作” 对<code>input输入框</code>、<code>pass密码输入框</code>、<code>textarea多行文本输入框</code>、<code>checkbox复选按钮</code>、<code>radio单选按钮</code>进行操作时，若实际的操作值(示例中的“xx”)为 <code>None</code> 则代表跳过不做操作。</li>
<li>无论使用哪种操作方法，在对<code>input输入框</code>、<code>pass密码输入框</code>、<code>textarea多行文本输入框</code>进行操作时，若实际的操作值(示例中的“xx”)为 <code>'clear'</code> 则代表只对输入框做清空操作，不输入任何值。</li>
</ul>
</li>
</ul>
<p><strong>方法使用场景示例</strong></p>
<blockquote>
<p>测试场景：</p>
<ul>
<li>登录表单id属性值为<code>login</code>，用户名输入框name属性值为<code>userName</code>，密码输入框name属性值为<code>userPass</code></li>
<li>信息修改表单name属性值为<code>inform</code>，姓名输入框name属性值为<code>name</code>，昵称输入框name属性值为<code>tranName</code>，年龄输入框name属性值为<code>age</code>，性别下拉列表框name属性值为<code>sex</code></li>
</ul>
</blockquote>
<ul>
<li>使用“按照组件先后顺序操作”操作方法，对登录表单进行填写：<code>{'Parent ':'#login','operationStep':{'input':['admin','123']}}</code></li>
<li>使用“指定组件操作”操作方法，对登录表单进行填写：<code>{'Parent ':'#login','operationStep':{'input':[['userName','admin'],['userPass','123']]}}</code></li>
<li>使用“指定组件操作”操作方法，对信息修改表单进行填写(昵称输入框不输入值)：<code>{'Parent ':'form[name="inform"]','operationStep':{'input':[['age','12'],['name','王小明']],'select':[['sex','男']]}}</code></li>
<li>使用“按照组件先后顺序操作”操作方法，对信息修改表单进行填写(昵称输入框不输入值)：<code>{'Parent ':'form[name="inform"]','operationStep':{'input':['12',None,'王小明'],'select':[['sex','男']]}}</code></li>
</ul>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[OA_webUI]FormInput</td>
<td></td>
<td align="left">{‘Parent’:‘表单定位表达式’, ‘operationStep’:‘操作数据’}</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[OA_webUI]FormInput</td>
<td></td>
<td></td>
<td align="left">{‘Parent’:‘表单定位表达式’, ‘operationStep’:‘操作数据’}</td>
</tr>
</tbody>
</table><p><strong>注意事项</strong></p>
<ul>
<li>插件方法仅支持一种传值方式：“{‘参数名’:‘参数值’…}字典指定参数传参”。</li>
<li>方法按照 “组件先后顺序操作” 方式进行操作，若传入的操作值个数大于实际的元素个数，则超出的操作值将被方法视为无效，且不对其进行操作。</li>
<li>方法中的 “组件先后顺序操作方式” 和 “指定组件操作方式” 在不同表单组件元素之间可以混合使用，但是同种表单组件元素只可以二选一，例如，你可以在一次调用中使用“组件先后顺序操作方式”操作input输入框，同时使用“指定组件操作方式”操作radio单选按钮，但是不能对第一个input输入框使用“组件先后顺序操作方式”操作，对第二个input输入框使用“指定组件操作方式”操作。</li>
<li>方法中<code>select下拉列表框</code>只支持通过 “指定组件操作方式” 进行操作，若“操作值个数大于实际的元素个数，超出的操作值将视为无效”特性不受用。</li>
<li>方法中除<code>select下拉列表框</code>外其它表单组件不论使用 “组件先后顺序操作方式” 还是 “指定组件操作方式”，“操作值个数大于实际的元素个数，超出的操作值将视为无效”这个特性均受用。</li>
</ul>
<hr>
<h3><a id="9goto_Modular_3231"></a>9、goto_Modular()</h3>
<blockquote>
<p>OA系统“菜单模块”跳转</p>
</blockquote>
<p><strong>描述</strong><br>
根据传入的“OA系统菜单标识”，进行相应的模块跳转</p>
<p><strong>参数</strong><br>
@param <strong>firstIden</strong> <code>string类型</code>：OA系统一级模块标识<br>
@param <strong>secondIden</strong> <code>string类型</code>：OA系统二级模块标识<br>
@param <strong>thirdIden</strong> <code>string类型</code>：OA系统三级模块标识<br>
@param <strong>tagIden</strong> <code>int类型 / string类型</code>：对应模块tag标签标识<br>
@param <strong>localSwitch</strong> <code>布尔类型</code>：局部操作开关</p>
<blockquote>
<p>firstIden 一级模块标识、secondIden 二级模块标识、thirdIden 三级模块标识，值均固定为特殊的字符标识，详情见<a href="https://blog.csdn.net/A1352074/article/details/131665400" target="_blank">《goto_Modular()插件方法 – TDOA web端模块菜单标识》</a></p>
</blockquote>
<blockquote>
<p>严格意义上来说方法中的参数并没有“可省略”这一概念，你需要根据实际需要选择要填写那些参数；具体的参数使用规则见下文 <strong>参数说明</strong></p>
</blockquote>
<p><strong>参数说明</strong></p>
<ul>
<li>全局操作；目标模块不存在子模块和tag标签页(例如：“个人事务-电子邮件”)：
<ul>
<li><code>{'firstIden':'personalAffairs','secondIden':'E_Mail'}</code> 或者 <code>['personalAffairs','E_Mail']</code></li>
</ul>
</li>
<li>全局操作；目标模块不存在子模块但存在tag标签页(例如：“个人事务-消息管理-微讯”)：
<ul>
<li><code>{'firstIden':'personalAffairs','secondIden':'Message','tagIden':0}</code></li>
</ul>
</li>
<li>全局操作；目标模块存在子模块但不存在tag标签页(例如：“行政办公-工作计划-工作计划类型设置”)：
<ul>
<li><code>{'firstIden':'administrativeOffice','secondIden':'Work_Plan','thirdIden':'Work_Plan_Type'}</code> 或者 <code>['administrativeOffice','Work_Plan','Work_Plan_Type']</code></li>
</ul>
</li>
<li>全局操作：目标模块存在子模块同时也存在tag标签页(例如：“行政办公-工作计划-工作计划管理-新建工作计划”)：
<ul>
<li><code>{'firstIden':'administrativeOffice','secondIden':'Work_Plan','thirdIden':'Work_Plan_Query', 'tagIden':1}</code> 或者 <code>['administrativeOffice','Work_Plan','Work_Plan_Query',1]</code></li>
</ul>
</li>
<li>局部操作：目标模块不存在tag标签页(例如：“个人事务-电子邮件” 、“行政办公-工作计划-工作计划类型设置”)：
<ul>
<li>进行一次全局操作(全局路由跳转),将模块跳转至“个人事务-电子邮件”模块 → 用例步骤 → 用例步骤 →… → <code>{'localSwitch':True}</code></li>
<li>进行一次全局操作(全局路由跳转),将模块跳转至“行政办公-工作计划-工作计划类型设置”模块 → 用例步骤 → 用例步骤 →… → <code>{'localSwitch':True}</code></li>
</ul>
</li>
<li>局部操作：目标模块存在tag标签页(例如：“个人事务-消息管理-微讯” 、“行政办公-工作计划-工作计划管理-新建工作计划”)：
<ul>
<li>进行一次全局操作(全局路由跳转),将模块跳转至“个人事务-消息管理-微讯”模块 → 用例步骤 → 用例步骤 →… → <code>{'tagIden':0,'localSwitch':True}</code></li>
<li>进行一次全局操作(全局路由跳转),将模块跳转至“行政办公-工作计划-工作计划管理-新建工作计划”模块 → 用例步骤 → 用例步骤 →… → <code>{'tagIden':1, 'localSwitch':True}</code></li>
</ul>
</li>
</ul>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[OA_webUI]goto_Modular</td>
<td></td>
<td align="left">{‘firstIden’:‘一级模块标识’,‘secondIden’:‘二级模块标识’,‘thirdIden’:‘三级模块标识’,‘tagIden’:‘模块tag标签标识’,‘localSwitch’: ‘局部操作开关’}</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[OA_webUI]goto_Modular</td>
<td></td>
<td></td>
<td align="left">{‘firstIden’:‘一级模块标识’,‘secondIden’:‘二级模块标识’,‘thirdIden’:‘三级模块标识’,‘tagIden’:‘模块tag标签标识’,‘localSwitch’: ‘局部操作开关’}</td>
</tr>
</tbody>
</table><p><strong>注意事项</strong></p>
<ul>
<li>方法适用于OA系统中的所有模块，包含所有“一级模块、二级模块、三级模块、tag页模块”；主要目的是为了简化“用例步骤文件”中的模块跳转步骤。</li>
<li>方法不会校验“各模块标识之间的层级关系是否有效以及其标识是否合法”，所以在使用时要注意检查你要操作的“模块标识”和“多级模块层级”是否正确。</li>
<li>方法传入的“<code>tagIden</code>对应模块tag标签标识”你只要确定其为阿拉伯数字即可，不必在意它的类型，在方法中会进行类型转换。</li>
<li>方法 “全局操作”：不考虑当前正在处于活动状态的“模块”，直接将整个OA系统还原成初始状态(无任何菜单展开，无任何模块打开)，并根据传入的各级标识打开指定的目标模块。</li>
<li>方法 “局部操作”：不会对系统“展开菜单项”和“定位任务标签”进行清空操作，而是直接跳过一、二级模块直接以三级模块或者tag标签模块为起点进行操作。</li>
<li>方法 “局部操作”不需要指定“各级模块标识”，但需要在调用方法进行“目标模块的局部操作”之前先调用方法完成一次“目标模块的全局操作”，目的则是为了获取“全局操作”所指定的各级模块标识信息。</li>
<li>方法 “局部操作”不支持用于模块之间的跳转，其本身目的只是为了用来刷新目标模块。</li>
<li>在使用“局部操作”刷新目标模块时，若不传入“<code>tagIden</code>对应模块tag标签标识”(不论目标模块有无tag标签页)则代表将该模块关闭(顶部选项卡)，并重新点击打开。</li>
</ul>
<hr>
<h3><a id="10intervention_Mysql_3282"></a>10、intervention_Mysql()</h3>
<blockquote>
<p>OA系统“数据库”操作</p>
</blockquote>
<p><strong>描述</strong><br>
根据传入数据库和数据表信息，连接并操作数据记录</p>
<p><strong>参数</strong><br>
@param <strong>localhost</strong> <code>string类型</code>：mysql数据库地址<br>
@param <strong>port</strong> <code>string类型 / int类型</code>： 端口号<br>
@param <strong>user</strong> <code>string类型</code>：用户名<br>
@param <strong>password</strong> <code>string类型</code>：密码<br>
@param <strong>charset</strong> <code>string类型</code>：字符编码<br>
@param <strong>database</strong> <code>string类型</code>：待操作数据库名称<br>
@param <strong>table</strong> <code>string类型</code>：待操作数据表名称<br>
@param <strong>operation</strong> <code>string类型</code>：操作标识<br>
@param <strong>where</strong> <code>string类型</code>：sql条件命令表达式<br>
@param <strong>instructString</strong> <code>dist类型</code>：字段名、字段值关系表达式</p>
<blockquote>
<p>where、instructString 参数可省略</p>
</blockquote>
<p><strong>参数说明</strong></p>
<ul>
<li>localhost：mysql数据库地址，没有特殊要求；</li>
<li>port：mysql服务的端口号，没有特殊要求你只要确定其为阿拉伯数字即可，不必在意它的类型，在方法中会进行类型转换；</li>
<li>user：mysql服务的用户名，没有特殊要求；</li>
<li>password：mysql服务的用户密码，没有特殊要求；</li>
<li>charset：字符编码，没有特殊要求；</li>
<li>database：待操作数据库的名称，没有特殊要求但要确保被操作的数据库真实存在；</li>
<li>table：待操作数据表的名称，确保被操作的数据表真实存在，且存在于<code>database 参数</code>指定的数据库中；</li>
<li>operation：操作标识，可输入值固定为 <code>delete</code>删除、<code>update</code>修改更新、<code>insert</code>插入；</li>
<li>where：sql条件命令表达式，语法和sql一致 <code>"'字段名'='字段值' AND ..."</code>，需要注意其中的 “字段名” 和 “字段值” 在书写时需要用 `` 符号包裹；</li>
<li>instructString：字段名、字段值关系表达式 <code>{'字段名':'值', '字段名': '值'...}</code>，需要注意其中的 “字段名” 和 “字段值” 在书写时不需要用 `` 符号包裹。</li>
<li>“where参数” 和 “instructString参数” 可选项说明：
<ul>
<li>当“operation操作动词”为 delete删除时：
<ul>
<li>where可选填；有值且合法：则删除数据表中符合条件的记录，值为空或者无该项：则删除数据表中全部记录；</li>
<li>instructString不参与处理，有无均可；</li>
</ul>
</li>
<li>当“operation操作动词”为 update更新时：
<ul>
<li>where可选填；有值且合法：则修改数据表中符合条件的记录，值为空或者无该项：则修改数据表中全部记录；</li>
<li>instructString必填项；代表要修改的字段名和其对应的字段值(保证书写的字段名和值类型与表中实际对应)，<code>{'name'='王小明', 'age': '12'}</code>；</li>
</ul>
</li>
<li>当“operation操作动词”为 insert插入时：
<ul>
<li>where不参与处理，有无均可；</li>
<li>instructString必填项；代表要插入记录的所有非空字段的字段名和其对应的字段值(保证书写的字段名和值类型与表中实际对应)，<code>{'name'='王小明', 'age': '12', 'class':'六年级', 'xb':'男'}</code>；</li>
</ul>
</li>
</ul>
</li>
</ul>
<p><strong>方法使用场景示例</strong></p>
<ul>
<li>实例一
<ul>
<li>删除 student表中所有的记录：<code>information = {table: 'studnet', operation: 'delete'}</code></li>
<li>删除 student表中 name字段值为“王小明”的记录：<code>information = {table: 'studnet', operation: 'delete', where: "'name'='王小明'"}</code></li>
</ul>
</li>
<li>实例二
<ul>
<li>将 student表中所有记录的 name字段值全部修改为 “王小明”：<code>information = {table: 'studnet', operation: 'update', instructString: {'name': '王小明'}}</code></li>
<li>将 student表中 age字段值为0的记录的 name字段值修改为 “王小明”：<code>information = {table: 'studnet', operation: 'update', instructString: {'name': '王小明'}, where: "'age'='0'"}</code></li>
</ul>
</li>
<li>实例三
<ul>
<li>向 student表中插入一条记录，其 name字段值为“王小明”、age字段值为12、class字段值为“六年级”、sex字段值为“男”：<code>information = {table: 'studnet', operation: 'insert', 'instructString': {'name':'王小明', 'age': '12', 'class':'六年级', 'xb':'男'}}</code></li>
</ul>
</li>
</ul>
<blockquote>
<p>为了方便阅读和理解，在上面的实例中并没有书写 “localhost、 port” 等信息，但是在实际使用时除了 “where参数” 和 “instructString参数”两项外其它均是必填项。</p>
</blockquote>
<p><strong>用例步骤使用示例</strong></p>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[OA_webUI]intervention_Mysql</td>
<td></td>
<td align="left">{}</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>[OA_webUI]intervention_Mysql</td>
<td></td>
<td></td>
<td align="left">{}</td>
</tr>
</tbody>
</table><p><strong>注意事项</strong></p>
<ul>
<li>方法目前仅支持对mysql数据库做操作</li>
</ul>
<hr>
<h1><a id="_3347"></a>框架内置函数说明</h1>
<p>内置函数：这里说的“内置函数”并不是函数方法，而是在框架中保留的带有特殊意义的字符串。目前框架中可支持识别的“内置函数”共有8个，其各自的函数名称以及所代表的含义如下所示：</p>
<blockquote>
<p>注意：<br>
1、“内置函数”只有在用例步骤的“操作值”单元格或着脚本关键字的实参参数值中书写才可被框架识别并处理。<br>
2、“内置函数”中的参数不论在何种场景下均不需要使用引号包裹，例如 <code>['System_date(%Y-%m-%d %H:%M:%S)']</code>  或者 <code>{'key': 'get_thisMonth(end)'}</code> 或者 <code>Increasing_date(2023-05-18, 1)</code>。<br>
3、存在联系的“内置函数”之间可以嵌套使用。<br>
4、“内置函数”没有使用个数和嵌套层级限制，你可以在一个“操作值单元格”或者“实参参数值”中书写或者嵌套多个“内置函数”，这并不会影响框架的识别。<br>
5、“内置函数”只能作为“操作值”或者“参数值”的一部分来参与执行，所以它必须要配合关键字或者插件方法一起使用，单独使用没有意义。</p>
</blockquote>
<h3><a id="1System_date_3357"></a>1、System_date()</h3>
<p><code>System_date()函数</code>：需要携带参数使用，携带参数为“日期时间格式字符串(%Y-%m-%d %H:%M:%S)”；代表返还一个指定格式的系统当前日期时间数据。示例如下：</p>

<table>
<thead>
<tr>
<th>处理前</th>
<th>处理后</th>
</tr>
</thead>
<tbody>
<tr>
<td>System_date(%Y-%m-%d %H:%M:%S)</td>
<td>2022-07-15 15:09:34</td>
</tr>
<tr>
<td>System_date(%Y-%m-%d)</td>
<td>2022-07-15</td>
</tr>
</tbody>
</table><p><strong>参数</strong><br>
日期格式字符串(%Y-%m-%d %H:%M:%S)</p>
<p><strong>说明</strong><br>
获取当前系统日期时间，根据传入的“日期格式字符串”生成对应格式的日期时间数据。</p>
<hr>
<h3><a id="2Increasing_date_3370"></a>2、Increasing_date()</h3>
<p><code>Increasing_date()函数</code>：需要携带参数使用，携带参数为“日期时间字符串, 递增值”；代表对一个指定的“日期时间”进行递增，该函数可以和“<code>System_date()函数</code>”嵌套使用。示例如下：</p>

<table>
<thead>
<tr>
<th>处理前</th>
<th>处理后</th>
</tr>
</thead>
<tbody>
<tr>
<td>Increasing_date(2022-07-15 15:11:03, 1)</td>
<td>2022-07-16 15:11:03</td>
</tr>
<tr>
<td>Increasing_date(System_date(%Y-%m-%d), -1)</td>
<td>2022-07-14</td>
</tr>
<tr>
<td>Increasing_date(System_date(%Y-%m-%d %H:%M:%S), -2)</td>
<td>2022-07-13 15:11:03</td>
</tr>
</tbody>
</table><p><strong>参数</strong><br>
日期时间数据, 递增天数  || System_date(日期格式字符串), 递增天数</p>
<p><strong>说明</strong><br>
对指定的日期时间数据进行指定天数的自增。</p>
<hr>
<h3><a id="3Intercept_date_3384"></a>3、Intercept_date()</h3>
<p><code>Intercept_date()函数</code>：需要携带参数使用，携带参数为“日期时间字符串, 截取类型”；代表对一个指定的“日期时间”进行指定部分的(Year年 / Month月 / Day日 / Hour时 / Min分 / Second秒)拆分，该函数同样可以和“<code>System_date()函数</code>”嵌套使用。示例如下：</p>

<table>
<thead>
<tr>
<th>处理前</th>
<th>处理后</th>
</tr>
</thead>
<tbody>
<tr>
<td>Intercept_date(2022-07-15 15:11:03, Year)</td>
<td>2022</td>
</tr>
<tr>
<td>Intercept_date(System_date(%Y-%m-%d), Month)</td>
<td>7</td>
</tr>
<tr>
<td>Intercept_date(Increasing_date(System_date(%Y-%m-%d %H:%M:%S), -2),Day)</td>
<td>13</td>
</tr>
<tr>
<td>Intercept_date(System_date(%Y-%m-%d %H:%M:%S),Hour)</td>
<td>15</td>
</tr>
</tbody>
</table><p><strong>参数</strong><br>
日期数据数据, 截取标识  || System_date(日期格式字符串), 截取标识</p>
<p><strong>说明</strong><br>
对指定的日期时间数据进行“Y年、m月、d日、H时、M分、S秒”单个位置的数据提取。<br>
截取标识：Year年 || Month月  || Day日  || Hour时 || Min分 || Second秒</p>
<hr>
<h3><a id="4Mktime_date_3400"></a>4、Mktime_date()</h3>
<p><code>Mktime_date()函数</code>：需要携带参数使用，携带参数为“日期时间字符串”；代表对一个指定的“日期时间”进行“时间戳转换”，该函数同样可以和“<code>System_date()函数</code>”嵌套使用。示例如下：</p>

<table>
<thead>
<tr>
<th>处理前</th>
<th>处理后</th>
</tr>
</thead>
<tbody>
<tr>
<td>Mktime_date(2022-07-15 15:16:03)</td>
<td>1659457600</td>
</tr>
<tr>
<td>Mktime_date(System_date(%Y-%m-%d))</td>
<td>1659434400</td>
</tr>
<tr>
<td>Mktime_date(Increasing_date(System_date(%Y-%m-%d %H:%M:%S), 2))</td>
<td>1673474817</td>
</tr>
</tbody>
</table><p><strong>参数</strong><br>
日期数据数据  || System_date(日期格式字符串)</p>
<p><strong>说明</strong><br>
将指定的日期时间数据转化成时间戳形式。</p>
<hr>
<h3><a id="5get_thisWeek_3414"></a>5、get_thisWeek()</h3>
<p><code>get_thisWeek()函数</code>：需要携带参数使用，携带参数为“start/end”；代表返还本周的开始日期/结束日期，示例如下：</p>

<table>
<thead>
<tr>
<th>处理前</th>
<th>处理后</th>
</tr>
</thead>
<tbody>
<tr>
<td>get_thisWeek(start)</td>
<td>2022-07-11</td>
</tr>
<tr>
<td>get_thisWeek(end)</td>
<td>2022-07-17</td>
</tr>
</tbody>
</table><p><strong>参数</strong><br>
start || end</p>
<p><strong>说明</strong><br>
获取本周的起始和截止日期，传入start为获取起始日期，传入end为获取截止日期。</p>
<hr>
<h3><a id="6get_thisMonth_3427"></a>6、get_thisMonth()</h3>
<p><code>get_thisMonth()函数</code>：需要携带参数使用，携带参数为“start/end”；代表返还本月的开始日期/结束日期，示例如下：</p>

<table>
<thead>
<tr>
<th>处理前</th>
<th>处理后</th>
</tr>
</thead>
<tbody>
<tr>
<td>get_thisMonth(start)</td>
<td>2022-07-01</td>
</tr>
<tr>
<td>get_thisMonth(end)</td>
<td>2022-07-31</td>
</tr>
</tbody>
</table><p><strong>参数</strong><br>
start || end</p>
<p><strong>说明</strong><br>
获取本月的起始和截止日期，传入start为获取起始日期，传入end为获取截止日期。</p>
<hr>
<h3><a id="7get_thisYear_3440"></a>7、get_thisYear()</h3>
<p><code>get_thisYear()函数</code>：需要携带参数使用，携带参数为“start/end”；代表返还本年的开始日期/结束日期，示例如下：</p>

<table>
<thead>
<tr>
<th>处理前</th>
<th>处理后</th>
</tr>
</thead>
<tbody>
<tr>
<td>get_thisYear(start)</td>
<td>2022-01-01</td>
</tr>
<tr>
<td>get_thisYear(end)</td>
<td>2022-12-31</td>
</tr>
</tbody>
</table><p><strong>参数</strong><br>
start || end</p>
<p><strong>说明</strong><br>
获取本年的起始和截止日期，传入start为获取起始日期，传入end为获取截止日期。</p>
<hr>
<h3><a id="8get_PrestoreData_3453"></a>8、get_PrestoreData()</h3>
<p><code>get_PrestoreData()函数</code>：携带参数和不携带参数均可使用，携带参数为“key键”；代表将通过<a id="getElementText"><code>getElementText()关键字</code></a> 存放在“元素信息缓存数据”中的数据取出，示例如下：</p>

<table>
<thead>
<tr>
<th>处理前</th>
<th>处理后</th>
</tr>
</thead>
<tbody>
<tr>
<td>get_PrestoreData(Key)</td>
<td>取出缓存数据中，Key键对应的Value值</td>
</tr>
<tr>
<td>get_PrestoreData()</td>
<td>取出缓存数据中，最后一个key键对应的value值</td>
</tr>
</tbody>
</table><p><strong>参数</strong><br>
数据在缓存时的key键 || 空</p>
<p><strong>说明</strong><br>
将由<a id="getElementText"><code>getElementText()关键字</code></a>缓存的数据值取出，若传入key键则取出对应的值；若不传入key键则默认将缓存数据中最后一个key键对应的value值取出；若传入的key键不存在则会抛出异常。</p>
<hr>
<h1><a id="_3466"></a>框架可识别替换标识说明</h1>
<p>替换标识：与“内置函数”等同，都是在框架中保留的带有特殊意义的字符串。目前框架中可支持识别的“替换标识”共有4个，其各自的名称以及所代表的含义如下所示：</p>
<blockquote>
<p>注：<br>
1、“替换标识”只有在“操作值”单元格中书写才可被框架识别并处理，它们可以作为参数值与关键字或者插件方法一起使用。<br>
2、“替换标识”没有个数限制，你可以在一个“操作值单元格”或者“实参参数值”中书写多个相同或者不同的标识，这并不会影响框架的识别。<br>
3、注意“替换标识”是区分大小写的，要严格按照规定书写，否则框架将无法识别。<br>
4、“替换标识”只能作为“操作值”或者“参数值”的一部分来参与执行，所以它必须要配合关键字或者插件方法一起使用，单独使用没有意义。</p>
</blockquote>

<table>
<thead>
<tr>
<th>标识</th>
<th>说明</th>
</tr>
</thead>
<tbody>
<tr>
<td>WORK_PATH-ROOT</td>
<td>识别为当前框架工作目录的路径</td>
</tr>
<tr>
<td>WORK_PATH-PACKET</td>
<td>识别为当前框架工作目录中“用例数据包”的路径</td>
</tr>
<tr>
<td>WORK_PATH-INTERFACE</td>
<td>识别为当前框架工作目录中“接口数据文件夹”的路径</td>
</tr>
<tr>
<td>WORK_PATH-ELEMENT</td>
<td>识别为当前框架工作目录中“元素节点数据文件夹”的路径</td>
</tr>
</tbody>
</table><h1><a id="_3481"></a>框架参数配置说明</h1>
<h2><a id="_3482"></a>一、参数配置文件</h2>
<p>在启动框架时，需要保证你当前的工作目录中存在“参数配置文件 parameters.json”(此处为默认名称，若是你自定义修改后此处应为修改后的名称)，若不存在则框架无法启动。</p>
<p><strong>命令方式创建</strong></p>
<ul>
<li><code>kdtest -p</code></li>
<li><code>kdtest --parameter</code></li>
</ul>
<blockquote>
<p>若文件已经存在框架会给予提示信息 “ file already exist！”</p>
</blockquote>
<p>文件也可自己手动创建，文件中应包含内容如下所示，用于注释说明的文本在手动创建时不需要书写(推荐使用命令方式创建该文件，通过命令方式创建的文件中会自动写入以下内容，按照文件的提示将参数配置完毕即可。)：</p>
<pre><code class="prism language-json"><span class="token punctuation">{</span>
    <span class="token string-property property">"//"</span><span class="token operator">:</span> <span class="token string">"待执行用例文件路径信息; 路径从casesAggregate用例数据包开始; 例如：casesAggregate\test\test1.xlsx"</span><span class="token punctuation">,</span>
    <span class="token string-property property">"testCaseFile"</span><span class="token operator">:</span> <span class="token punctuation">[</span>
        <span class="token punctuation">{</span>
            <span class="token string-property property">"//"</span><span class="token operator">:</span> <span class="token string">"用例步骤文件路径(必填不可省略)"</span><span class="token punctuation">,</span>
            <span class="token string-property property">"caseFilePath"</span><span class="token operator">:</span> <span class="token string">" casesAggregate\test\test1.xlsx "</span><span class="token punctuation">,</span>
            <span class="token string-property property">"//"</span><span class="token operator">:</span> <span class="token string">"待执行用例编号(用例对应的sheet表名)；为空或者不书写(且未设置 caseStart 和 caseEnd 两项)则代表按文件中的顺序执行全部"</span><span class="token punctuation">,</span>
            <span class="token string-property property">"caseItem"</span><span class="token operator">:</span> <span class="token punctuation">[</span><span class="token string">"xxxx"</span><span class="token punctuation">,</span> <span class="token string">"xxxx"</span><span class="token punctuation">]</span><span class="token punctuation">,</span>
            <span class="token string-property property">"//"</span><span class="token operator">:</span> <span class="token string">"待执行用例区间-起始用例编号(包含在执行区间内)(用例对应的sheet表名)；为空或者不书写则代表从文件中第一条用例开始，若设置了caseItem参数则该项无效"</span><span class="token punctuation">,</span>
            <span class="token string-property property">"caseStart"</span><span class="token operator">:</span> <span class="token string">"xxxx"</span><span class="token punctuation">,</span>
            <span class="token string-property property">"//"</span><span class="token operator">:</span> <span class="token string">"待执行用例区间-截止用例编号(包含在执行区间内)(用例对应的sheet表名)；为空或者不书写则代表到文件中最后一条用例结束，若设置了caseItem参数则该项无效"</span><span class="token punctuation">,</span>
            <span class="token string-property property">"caseEnd"</span><span class="token operator">:</span> <span class="token string">"xxxx"</span><span class="token punctuation">,</span>
            <span class="token string-property property">"//"</span><span class="token operator">:</span> <span class="token string">"接口脚本执行开关 [True || False]"</span><span class="token punctuation">,</span>
            <span class="token string-property property">"interfaceSwitch"</span><span class="token operator">:</span> <span class="token boolean">true</span>
        <span class="token punctuation">}</span><span class="token punctuation">,</span>
        <span class="token punctuation">{</span>
            <span class="token string-property property">"caseFilePath"</span><span class="token operator">:</span> <span class="token string">" casesAggregate\test1.xlsx "</span><span class="token punctuation">,</span>
            <span class="token string-property property">"caseItem"</span><span class="token operator">:</span> <span class="token punctuation">[</span><span class="token string">"xxxx"</span><span class="token punctuation">,</span> <span class="token string">"xxxx"</span><span class="token punctuation">]</span><span class="token punctuation">,</span>
            <span class="token string-property property">"caseStart"</span><span class="token operator">:</span> <span class="token string">"xxxx"</span><span class="token punctuation">,</span>
            <span class="token string-property property">"caseEnd"</span><span class="token operator">:</span> <span class="token string">"xxxx"</span><span class="token punctuation">,</span>
            <span class="token string-property property">"interfaceSwitch"</span><span class="token operator">:</span> <span class="token boolean">true</span>
        <span class="token punctuation">}</span>
    <span class="token punctuation">]</span><span class="token punctuation">,</span>
    <span class="token string-property property">"//"</span><span class="token operator">:</span> <span class="token string">"测试环境配置信息  @browser: 浏览器平台 [Chrome, Edge, Firefox, IE]  @url: 被测系统地址 [http:// || https://]  @implicitlyWait: 隐式等待时长 [0 - n]"</span><span class="token punctuation">,</span>
    <span class="token string-property property">"testEnvironment"</span><span class="token operator">:</span> <span class="token punctuation">{</span><span class="token string-property property">"browser"</span><span class="token operator">:</span> <span class="token string">"Chrome"</span><span class="token punctuation">,</span><span class="token string-property property">"url"</span><span class="token operator">:</span> <span class="token string">"http://localhost"</span><span class="token punctuation">,</span><span class="token string-property property">"implicitlyWait"</span><span class="token operator">:</span> <span class="token number">10</span><span class="token punctuation">}</span><span class="token punctuation">,</span>
    <span class="token string-property property">"//"</span><span class="token operator">:</span> <span class="token string">"辅助功能配置  @retrySwitch: 用例出错二次重试开关 [True || False]"</span><span class="token punctuation">,</span>
    <span class="token string-property property">"auxiliaryFunction"</span><span class="token operator">:</span> <span class="token punctuation">{</span><span class="token string-property property">"retrySwitch"</span><span class="token operator">:</span> <span class="token boolean">false</span><span class="token punctuation">}</span><span class="token punctuation">,</span>
    <span class="token string-property property">"//"</span><span class="token operator">:</span> <span class="token string">"自定义参数，可在用例中通过`参数名`直接调用"</span><span class="token punctuation">,</span>
    <span class="token string-property property">"selfDefinedParameter"</span><span class="token operator">:</span><span class="token punctuation">{</span><span class="token string-property property">"参数名 key"</span><span class="token operator">:</span> <span class="token string">"参数值 value"</span><span class="token punctuation">,</span><span class="token operator">...</span><span class="token punctuation">}</span>
<span class="token punctuation">}</span>
</code></pre>
<blockquote>
<p>注意：文件中的所有参数名均区分大小写，且不允许更改</p>
</blockquote>
<h2><a id="_3525"></a>二、配置参数解释</h2>
<h3><a id="1testCaseFile_3526"></a>1、testCaseFile</h3>
<p>待执行用例文件路径信息 <code>list类型</code>；其子项为dict类型存在多少个子项就代表框架要执行多少个用例步骤文件。</p>
<p><strong>参数子项解释</strong>：</p>
<ul>
<li><code>caseFilePath</code>：用例步骤文件路径(必填不可省略)；</li>
<li><code>caseItem</code>：待执行用例编号(用例对应的sheet表名)；为空或者不书写(且未设置 caseStart 和caseEnd 两项)则代表按文件中的顺序执行全部；</li>
<li><code>caseStart</code>：待执行用例区间-起始用例编号(包含在执行区间内)(用例对应的sheet表名)；为空或者不书写则代表从文件中第一条用例开始，若设置了caseItem参数则该项无效；</li>
<li><code>caseEnd</code>：待执行用例区间-截止用例编号(包含在执行区间内)(用例对应的sheet表名)；为空或者不书写则代表到文件中最后一条用例结束，若设置了caseItem参数则该项无效；</li>
<li><code>interfaceSwitch</code>：接口脚本执行开关；</li>
</ul>
<p><strong>注意事项</strong></p>
<ul>
<li>待执行用例文件路径信息; 路径应从casesAggregate用例数据包开始; 例如： casesAggregate\test\test1.xlsx。</li>
<li>若设置了<code>caseItem</code> 参数则<code>caseStart</code> 和 <code>caseEnd</code>两项不论设置与否均不生效。</li>
<li>若在<code>caseFilePath</code>、<code>caseItem</code>、<code>caseStart</code>、 <code>caseEnd</code>四项参数中输入的值不合法(文件路径地址错误、sheet表不存在)，则框架会终止执行，并在控制台中打印提示信息。</li>
<li><code>interfaceSwitch</code> 参数接收值类型为布尔值，True代表在用例执行前先运行用例对应的接口脚本，Fasle则代表仅执行用例。</li>
</ul>
<h3><a id="2testEnvironment_3541"></a>2、testEnvironment</h3>
<p>测试环境配置信息 <code>dict类型</code>；用于存放“测试浏览器平台”、“被测系统地址”和“全局隐式等待时长”</p>
<p><strong>参数子项解释</strong>：</p>
<ul>
<li><code>browser</code>: 测试的浏览器平台 [Chrome, Edge, Firefox, IE]</li>
<li><code>url</code>: 被测系统地址 [http:// || https://]</li>
<li><code>implicitlyWait</code>: 隐式等待时长 [0 - n]</li>
</ul>
<p><strong>注意事项</strong></p>
<ul>
<li>目前框架可支持选择的“测试浏览器平台”有： “Chrome浏览器”、“Edge浏览器”、“Firefox浏览器”和“IE浏览器”。</li>
<li>注意在选择对应浏览器执行测试用例之前，需要先确保测试机中存在浏览器对应的驱动程序。</li>
</ul>
<h3><a id="3auxiliaryFunction_3552"></a>3、auxiliaryFunction</h3>
<p>测试环境配置信息 <code>dict类型</code>；用于存放一些框架中的“辅助功能开关”，目前框架中仅支持识别一个辅助开关 <code>retrySwitch</code></p>
<p><strong>参数子项解释</strong>：</p>
<ul>
<li><code>retrySwitch</code>: 用例出错二次复测开关；</li>
</ul>
<p><strong>注意事项</strong></p>
<ul>
<li><code>retrySwitch</code> 参数接收值类型为布尔值，True代表当用例执行结果为“FAIL 未通过” 或者 “ABNORMAL 异常”时，再次执行一次用例，False则代表用例仅执行一次无论结果是否为“PASS 通过”。</li>
</ul>
<h3><a id="4selfDefinedParameter_3560"></a>4、selfDefinedParameter</h3>
<p>自定义参数 <code>dict类型</code>；参数的数量和命名规则均无限制，在此处命名的参数在“用例”或者“接口”可通过“参数名”直接调用，在脚本中可通过框架中的共享参数<code>GSTORE['START']['selfDefinedParameter']['参数名']</code>完成调用。</p>
<blockquote>
<p>需要注意参数名的长度需要大于等于6个字符，过短的参数名会导致框架无法识别</p>
</blockquote>
<p><strong>示例</strong>：</p>
<blockquote>
<p>selfDefinedParameter：{“userName”:“admin”}</p>
</blockquote>
<ul>
<li>在用例中调用</li>
</ul>

<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>元素定位信息</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>xxx</td>
<td>xxx</td>
<td align="left">userName</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th>用例name</th>
<th>序号</th>
<th>操作步骤</th>
<th>关键字</th>
<th>定位方式</th>
<th>定位表达式</th>
<th align="left">操作值</th>
</tr>
</thead>
<tbody>
<tr>
<td>不区分元素定位数据</td>
<td>n</td>
<td>xxx</td>
<td>xxx</td>
<td>xxx</td>
<td>xxx</td>
<td align="left">userName</td>
</tr>
</tbody>
</table><ul>
<li>在接口中调用</li>
</ul>
<pre><code class="prism language-yaml"><span class="token key atrule">xxxx</span><span class="token punctuation">:</span>
  <span class="token key atrule">_PARAMETERS</span><span class="token punctuation">:</span>
    <span class="token key atrule">METHOD</span><span class="token punctuation">:</span> xxx
    <span class="token key atrule">URL</span><span class="token punctuation">:</span> xxxx/xxxx/xxxx
    <span class="token key atrule">HEADER</span><span class="token punctuation">:</span>
      <span class="token key atrule">Content-Type</span><span class="token punctuation">:</span> application/x<span class="token punctuation">-</span>www<span class="token punctuation">-</span>form<span class="token punctuation">-</span>urlencoded
    <span class="token key atrule">DATA</span><span class="token punctuation">:</span>
      <span class="token key atrule">UNAME</span><span class="token punctuation">:</span> userName
      <span class="token key atrule">PASSWORD</span><span class="token punctuation">:</span> xx
      <span class="token key atrule">encode_type</span><span class="token punctuation">:</span> xx
    <span class="token key atrule">REGULAR</span><span class="token punctuation">:</span> xxxx
  <span class="token key atrule">_RESULT</span><span class="token punctuation">:</span> xxxx
  <span class="token key atrule">_RS</span><span class="token punctuation">:</span> None
</code></pre>
<ul>
<li>在脚本中调用</li>
</ul>
<pre><code class="prism language-python">form kdtest <span class="token keyword">import</span> GSTORE
<span class="token keyword">print</span><span class="token punctuation">(</span>GSTORE<span class="token punctuation">[</span><span class="token string">'START'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token string">'selfDefinedParameter'</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token string">'userName'</span><span class="token punctuation">]</span><span class="token punctuation">)</span>  <span class="token comment"># GSTORE['START']['selfDefinedParameter'] 此部分为固定</span>
</code></pre>
<h1><a id="_3599"></a>自定义插件开发</h1>
<h2><a id="_3600"></a>一、注意事项</h2>
<ul>
<li>
<p>当你键入 <code>kdtest --unit_new</code> 命令后，框架会在你当前的工作目录中创建一个“自定义插件包模板”，其默认命名为<code>plugins</code>(名称可按照个人喜好自定义)你需要注意该文件夹只是一个容器起到收纳的作用，其下的<code>CJ_1</code>(名称可按照个人喜好自定义)文件夹才是一个可以被框架识别的插件包。</p>
</li>
<li>
<p>框架将一个由 <code>my.ini</code>(名称可按照个人喜好自定义)、<code>module.py</code>(名称可按照个人喜好自定义，下文统称为“插件模块文件”) 和 <code>__init__.py</code>三个文件组成的文件夹视为一个合法的插件包。当然这些文件会随着 <code>kdtest --unit_new</code> 命令的执行自动生成。</p>
</li>
<li>
<p>通过键入命令默认生成的插件包中的<code>elementData</code> 和 <code>utils</code> 文件夹起到辅助“插件模块文件”执行的作用(名称可按照个人喜好修改默认值，也可以直接修改实际的文件夹名称)，分别用于存放 “插件模块文件中的依赖数据” 和 “辅助工具方法”；框架对其无任何限制，若是你不需要可以直接删除。</p>
</li>
<li>
<p>插件包中的<code>__init__.py</code>文件不必编写，且名称不可修改，只是让Python认为该插件包是一个模块。</p>
</li>
<li>
<p>插件包中的<code>my.ini</code>文件是整个插件包的配置文件，共由<code>NAME</code>、<code>DETAILE</code>、<code>STATE</code>三项组成，分别代表 “插件包名”、“插件包详细说明” 和 “插件包当前状态”。</p>
<pre><code class="prism language-ini"># my.ini

[Information]
NAME = "插件名，注意：此处插件名不应由引号包裹 NAME = cj1"

DETAILE = "插件详细描述；可省略不写"

STATE = "插件状态[finish 可用, update 持续更新, disabled 暂不可用]"
</code></pre>
</li>
<li>
<p>插件包中的<code>module.py</code>文件为框架在调用时的直接引用文件，对其并没有命名限制你可以自己定义，但需要注意要与文件中的class类名和 <code>my.ini</code>文件中的NAME插件包名一致。</p>
<pre><code class="prism language-python"><span class="token comment"># module.py</span>

<span class="token comment"># 注意class类名要与my.ini文件中的模块名和插件文件.py文件名一致</span>
<span class="token keyword">class</span> <span class="token class-name">module</span><span class="token punctuation">(</span><span class="token builtin">object</span><span class="token punctuation">)</span><span class="token punctuation">:</span>
    <span class="token keyword">def</span> <span class="token function">__init__</span><span class="token punctuation">(</span>self<span class="token punctuation">)</span> <span class="token operator">-</span><span class="token operator">&gt;</span> <span class="token boolean">None</span><span class="token punctuation">:</span>
        <span class="token keyword">return</span>

    <span class="token keyword">def</span> <span class="token function">__call__</span><span class="token punctuation">(</span>self<span class="token punctuation">)</span> <span class="token operator">-</span><span class="token operator">&gt;</span> <span class="token boolean">None</span><span class="token punctuation">:</span>
        <span class="token comment"># 可自己定义和编写，没有规则限制</span>
        <span class="token keyword">return</span>
    
    <span class="token keyword">def</span> <span class="token function">functionOne</span><span class="token punctuation">(</span>self<span class="token punctuation">)</span> <span class="token operator">-</span><span class="token operator">&gt;</span> <span class="token boolean">None</span><span class="token punctuation">:</span>
        <span class="token comment"># 可自己定义和编写，没有规则限制</span>
        <span class="token keyword">return</span>
</code></pre>
</li>
</ul>
<blockquote>
<p>注意：插件包中的<code>module.py</code>文件的命名需要与文件中的class类名和 <code>my.ini</code>文件中的NAME插件包名一致，否则框架将无法声明和使用它。 <code>文件名 == class类名 == NAME插件包名</code></p>
</blockquote>
<h2><a id="_3635"></a>二、安装、卸载、显示</h2>
<ul>
<li>你可以通过键入 <code>-&gt; kdtest --unit_install C:\\xxx\\xxx\\xxx</code> 命令将你自定义的插件包安装到框架中，命令支持多参数传递；<code>C:\\xxx\\xxx\\xxx</code> 为你自定义插件包的绝对路径。</li>
<li>若你想对一个已经安装的插件包进行更新，则可直接键入 <code>-&gt; kdtest --unit_install C:\\xxx\\xxx\\xxx</code> 命令，框架会询问你是否需要进行更新。</li>
<li>你可以通过键入 <code>-&gt; kdtest --unit_uninstall name</code> 命令将一个已经安装的插件从框架中移除，命令支持多参数传递；<code>name</code> 为你自定义插件包的名称。</li>
<li>你可以通过键入 <code>-&gt; kdtest --unit_show</code> 命令将目前框架所有安装的插件包显示出来。</li>
</ul>
<pre><code class="prism language-cmd">-&gt; kdtest --unit_install D:\python\plugins\OA_webUI
-&gt; Plug-in installed successfully ! D:\python\plugins\OA_webUI  # 安装成功
-&gt; kdtest --unit_show  # 显示
-&gt; ----------------------------------------
-&gt;  Name  |            OA_webUI
-&gt; ----------------------------------------
-&gt; 
-&gt; -------------------------------------------------------------------------
-&gt; kdtest --unit_install D:\python\plugins\OA_webUI  # 更新
-&gt; The plug-in package has been installed !, Whether to update D:\python\plugins\OA_webUI : Y/N? Y  # 同意更新
-&gt; Plug-in update successful ! D:\python\plugins\OA_webUI
-&gt; 
-&gt; -------------------------------------------------------------------------
-&gt; kdtest --unit_uninstall OA_webUI  # 卸载
-&gt; Confirm whether to delete the plug-in: OA_webUI: Y/N? Y # 同意卸载
-&gt; √ Plug-in removed: OA_webUI  # 卸载成功
-&gt; kdtest --unit_show  # 显示
-&gt; No plug-in is available !   # 不存在任何插件
</code></pre>
<blockquote>
<p>注意在插件包安装、更新和卸载的过程中，框架会自动识别插件包中的第三方依赖库，并将这些库自动安装和卸载(卸载时会征求你的同意，避免误删)；该功能仅在 <code>1.1.3</code> 及以上版本的框架中支持。</p>
</blockquote>
<blockquote>
<p>注意：若你将一个已经安装的插件包的名称修改后再次进行安装操作，框架会将其视为一个新的插件；并不会触发更新操作。</p>
</blockquote>
<blockquote>
<p>多参数传递规则为 <code>kdtest --unit_install xxxx  --unit_install xxxx</code></p>
</blockquote>
<blockquote>
<p>在解释中提到的文件或文件夹名称修改方法，见“注意事项 - 可自定义的文件、文件夹名称修改方法代码展示”</p>
</blockquote>

    </div>
</body>
<script type="text/javascript">
	var html = document.getElementById("stackedit")
	var reg = new RegExp("<pre","g");
	var content = html.innerHTML;
	html.innerHTML = content.replace(reg, "<pre class='prettyprint linenums'");
</script>


</html>
